/// <summary> /// Computes the influence of all configuration options and interactions based on the measurements of the given result db. It uses linear programming (simplex) and is an exact algorithm. /// </summary> /// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param> /// <param name="infModel">The influence model containing the variability model, all configuration options and interactions.</param> /// <param name="db">The result database containing the measurements.</param> /// <param name="evaluateFeatureInteractionsOnly">Only interactions are learned.</param> /// <param name="withDeviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param> /// <param name="deviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param> /// <returns>Returns the learned infleunces of each option in a map whereas the String (Key) is the name of the option / interaction.</returns> public Dictionary <String, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db, bool evaluateFeatureInteractionsOnly, bool withDeviation, double deviation) { //Initialization List <List <BinaryOption> > configurations = new List <List <BinaryOption> >(); this.evaluateInteractionsOnly = evaluateFeatureInteractionsOnly; this.withStandardDeviation = withDeviation; this.standardDeviation = deviation; List <double> results = new List <double>(); foreach (Configuration c in db.Configurations) { configurations.Add(c.getBinaryOptions(BinaryOption.BinaryValue.Selected)); if (nfp != null) { results.Add(c.GetNFPValue(nfp)); } else { results.Add(c.GetNFPValue()); } } List <BinaryOption> variables = new List <BinaryOption>(); Dictionary <String, double> featureValues = new Dictionary <string, double>(); Dictionary <String, double> faultRates = new Dictionary <string, double>(); List <int> indexOfErrorMeasurements = new List <int>(); if (configurations.Count == 0) { return(null); } //For the case there is an empty base if (configurations.Count != 0) { if (configurations[0].Count == 0) {//Should never occur that we get a configuration with no option selected... at least the root must be there BinaryOption root = infModel.Vm.Root; //Element baseElement = new Element("base_gen", infModel.getID(), infModel); //variables.Add(baseElement); // featureValues.Add(baseElement.getName(), 0); foreach (List <BinaryOption> config in configurations) { if (!config.Contains(root)) { config.Insert(0, root); } } } } //Building the variable list foreach (var elem in infModel.Vm.BinaryOptions) { variables.Add(elem); featureValues.Add(elem.Name, 0); } featureValues = solve(variables, results, configurations, null); return(featureValues); }
/// <summary> /// Computes the influence of all configuration options based on the measurements of the given result db. It uses linear programming (simplex) and is an exact algorithm. /// </summary> /// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param> /// <param name="infModel">The influence model containing options and interactions. The state of the model will be changed by the result of the process</param> /// <param name="db">The result database containing the measurements.</param> /// <returns>A map of binary options to their computed influences.</returns> public Dictionary <BinaryOption, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db) { List <BinaryOption> variables = infModel.Vm.BinaryOptions; List <double> results = new List <double>(); List <List <BinaryOption> > configurations = new List <List <BinaryOption> >(); foreach (Configuration c in db.Configurations) { configurations.Add(c.getBinaryOptions(BinaryOption.BinaryValue.Selected)); if (nfp != null) { results.Add(c.GetNFPValue(nfp)); } else { results.Add(c.GetNFPValue()); } } List <String> errorEqs = new List <string>(); Dictionary <String, double> faultRates = new Dictionary <string, double>(); List <int> indexOfErrorMeasurements = new List <int>(); Dictionary <String, double> featureValuedAsStrings = solve(variables, results, configurations, infModel.InteractionInfluence.Keys.ToList()); foreach (String current in featureValuedAsStrings.Keys) { BinaryOption temp = infModel.Vm.getBinaryOption(current); this.featureValues[temp] = featureValuedAsStrings[current]; InfluenceFunction influence = new InfluenceFunction(temp.Name + " + " + featureValuedAsStrings[current].ToString(), infModel.Vm); if (infModel.BinaryOptionsInfluence.Keys.Contains(temp)) { infModel.BinaryOptionsInfluence[temp] = influence; } else { infModel.BinaryOptionsInfluence.Add(temp, influence); } } return(this.featureValues); }
public void learn(List <Feature> featureSet = null) { if (!hasNecessaryData()) { return; } if (this.mlSettings.bagging) { //Get number of cores int coreCount = System.Environment.ProcessorCount; createThreadPool(coreCount); this.nbBaggings = this.mlSettings.baggingNumbers; iCount = this.nbBaggings; Random rand = new Random(0); int nbOfConfigs = (testSet.Count * this.mlSettings.baggingTestDataFraction) / 100; for (int i = 0; i < nbBaggings; i++) { InfluenceModel infMod = new InfluenceModel(GlobalState.varModel, GlobalState.currentNFP); FeatureSubsetSelection sel = new FeatureSubsetSelection(infMod, this.mlSettings); this.models.Add(sel); List <int> selection = new List <int>(); for (int r = 0; r <= nbOfConfigs; r++) { selection.Add(rand.Next(nbOfConfigs)); } List <Configuration> newTestSet = new List <Configuration>(); List <Configuration> newValidationSet = new List <Configuration>(); for (int r = 0; r <= selection.Count; r++) { if (selection.Contains(r)) { newTestSet.Add(testSet[r]); } else { newValidationSet.Add(testSet[r]); } } sel.setLearningSet(newTestSet); sel.setValidationSet(newValidationSet); Task task = EnqueueTask(() => sel.learn()); } eventX.WaitOne(Timeout.Infinite, true); averageModels(); } else { GlobalState.logInfo.logLine("Learning progress:"); InfluenceModel infMod = new InfluenceModel(GlobalState.varModel, GlobalState.currentNFP); FeatureSubsetSelection sel = new FeatureSubsetSelection(infMod, this.mlSettings); this.models.Add(sel); sel.setLearningSet(testSet); sel.setValidationSet(this.validationSet); Stopwatch sw = new Stopwatch(); sw.Start(); sel.learn(featureSet); sw.Stop(); Console.WriteLine("Elapsed={0}", sw.Elapsed); } }
public BettyFileParser() { _varModel = new VariabilityModel("generated"); _inflModel = new InfluenceModel(_varModel, new NFProperty("nfp")); }
/// <summary> /// This method searches for a corresponding methods in the dynamically loadeda assemblies and calls it if found. It prefers due to performance reasons the Microsoft Solver Foundation implementation. /// </summary> /// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param> /// <param name="infModel">The influence model containing options and interactions. The state of the model will be changed by the result of the process</param> /// <param name="db">The result database containing the measurements.</param> /// <returns>A map of binary options to their computed influences.</returns> public Dictionary <BinaryOption, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db) { foreach (Lazy <ISolverLP, ISolverType> solver in solvers) { if (solver.Metadata.SolverType.Equals("MSSolverFoundation")) { return(solver.Value.computeOptionInfluences(nfp, infModel, db)); } } //If not MS Solver, take any solver. Should be changed when supporting more than 2 solvers here foreach (Lazy <ISolverLP, ISolverType> solver in solvers) { return(solver.Value.computeOptionInfluences(nfp, infModel, db)); } return(null); }