public List <Configuration> GenerateAllVariants(VariabilityModel vm, List <ConfigurationOption> optionsToConsider)
{
HashSet <Configuration> results = new HashSet <Configuration>();
Cplex plex = initCplex(vm);
initializeNumericVariables(plex, vm);
setPopulateParams(plex, MAX_NUMBER_SOLUTION);
populate(plex, MAX_NUMBER_SOLUTION);
for (int i = 0; i < plex.GetSolnPoolNsolns(); i++)
{
Dictionary <BinaryOption, BinaryOption.BinaryValue> binOpts = new Dictionary <BinaryOption, BinaryOption.BinaryValue>();
Dictionary <NumericOption, double> numOpts = new Dictionary <NumericOption, double>();
Configuration toAdd;
foreach (ConfigurationOption option in vm.getOptions())
{
if (optionsToConsider != null && !optionsToConsider.Contains(option))
{
continue;
}
if (option is BinaryOption)
{
if (plex.GetValue(binOptsToCplexVars[(BinaryOption)option], i) > EPSILON_THRESHOLD)
{
binOpts[(BinaryOption)option] = BinaryOption.BinaryValue.Selected;
}
else
{
binOpts[(BinaryOption)option] = BinaryOption.BinaryValue.Deselected;
}
}
else
{
numOpts[(NumericOption)option] = plex.GetValue(numOptsToCplexVars[(NumericOption)option], i);
}
}
toAdd = new Configuration(binOpts, numOpts);
// Check if the non-boolean constraints are satisfied
if (!results.Contains(toAdd) && vm.configurationIsValid(toAdd) &&
VariantGenerator.FulfillsMixedConstraints(toAdd, vm))
{
results.Add(toAdd);
}
}
plex.Dispose();
return(results.ToList());
}
/// <summary>
/// Generates all valid combinations of all configuration options in the given model.
/// </summary>
/// <param name="vm">the variability model containing the binary options and their constraints</param>
/// <param name="optionsToConsider">the options that should be considered. All other options are ignored</param>
/// <returns>Returns a list of <see cref="Configuration"/></returns>
public List <Configuration> GenerateAllVariants(VariabilityModel vm, List <ConfigurationOption> optionsToConsider)
{
List <Configuration> allConfigurations = new List <Configuration>();
List <BoolExpr> variables;
Dictionary <BoolExpr, BinaryOption> termToOption;
Dictionary <BinaryOption, BoolExpr> optionToTerm;
Tuple <Context, BoolExpr> z3Tuple = Z3Solver.GetInitializedBooleanSolverSystem(out variables, out optionToTerm, out termToOption, vm, this.henard);
Context z3Context = z3Tuple.Item1;
BoolExpr z3Constraints = z3Tuple.Item2;
Microsoft.Z3.Solver solver = z3Context.MkSolver();
// TODO: The following line works for z3Solver version >= 4.6.0
//solver.Set (RANDOM_SEED, z3RandomSeed);
Params solverParameter = z3Context.MkParams();
solverParameter.Add(RANDOM_SEED, z3RandomSeed);
solver.Parameters = solverParameter;
solver.Assert(z3Constraints);
while (solver.Check() == Status.SATISFIABLE)
{
Model model = solver.Model;
List <BinaryOption> binOpts = RetrieveConfiguration(variables, model, termToOption, optionsToConsider);
Configuration c = new Configuration(binOpts);
// Check if the non-boolean constraints are satisfied
if (vm.configurationIsValid(c) && !VariantGenerator.IsInConfigurationFile(c, allConfigurations) && VariantGenerator.FulfillsMixedConstraints(c, vm))
{
allConfigurations.Add(c);
}
solver.Push();
solver.Assert(Z3Solver.NegateExpr(z3Context, Z3Solver.ConvertConfiguration(z3Context, binOpts, optionToTerm, vm)));
}
solver.Push();
solver.Pop(Convert.ToUInt32(allConfigurations.Count() + 1));
return(allConfigurations);
}
/// <summary>
/// Generates all valid combinations of all configuration options in the given model.
/// </summary>
/// <param name="vm">the variability model containing the binary options and their constraints</param>
/// <param name="optionsToConsider">the options that should be considered. All other options are ignored</param>
/// <returns>Returns a list of <see cref="Configuration"/></returns>
public List <Configuration> GenerateAllVariants(VariabilityModel vm, List <ConfigurationOption> optionsToConsider)
{
List <Configuration> allConfigurations = new List <Configuration>();
List <Expr> variables;
Dictionary <Expr, ConfigurationOption> termToOption;
Dictionary <ConfigurationOption, Expr> optionToTerm;
Tuple <Context, BoolExpr> z3Tuple = Z3Solver.GetInitializedSolverSystem(out variables, out optionToTerm, out termToOption, vm);
Context z3Context = z3Tuple.Item1;
BoolExpr z3Constraints = z3Tuple.Item2;
Microsoft.Z3.Solver solver = z3Context.MkSolver();
solver.Set(RANDOM_SEED, z3RandomSeed);
solver.Assert(z3Constraints);
while (solver.Check() == Status.SATISFIABLE)
{
Model model = solver.Model;
Tuple <List <BinaryOption>, Dictionary <NumericOption, double> > confOpts = RetrieveConfiguration(variables, model, termToOption, optionsToConsider);
Configuration c = new Configuration(confOpts.Item1, confOpts.Item2);
// Check if the non-boolean constraints are satisfied
bool configIsValid = vm.configurationIsValid(c);
bool isInConfigurationFile = !VariantGenerator.IsInConfigurationFile(c, allConfigurations);
bool fulfillsMixedConstraintrs = VariantGenerator.FulfillsMixedConstraints(c, vm);
if (configIsValid && isInConfigurationFile && fulfillsMixedConstraintrs)
{
allConfigurations.Add(c);
}
solver.Push();
solver.Assert(Z3Solver.NegateExpr(z3Context, Z3Solver.ConvertConfiguration(z3Context, confOpts.Item1, optionToTerm, vm, numericValues: confOpts.Item2)));
}
solver.Push();
solver.Pop(Convert.ToUInt32(allConfigurations.Count() + 1));
return(allConfigurations);
}
/// <summary>
/// Performs the functionality of one command. If no functionality is found for the command, the command is retuned by this method.
/// </summary>
/// <param name="line">One command with its parameters.</param>
/// <returns>Returns an empty string if the command could be performed by the method. If the command could not be performed by the method, the original command is returned.</returns>
public string performOneCommand(string line)
{
GlobalState.logInfo.logLine(COMMAND + line);
// remove comment part of the line (the comment starts with an #)
line = line.Split(new Char[] { '#' }, 2)[0];
if (line.Length == 0)
return "";
// split line in command and parameters of the command
string[] components = line.Split(new Char[] { ' ' }, 2);
string command = components[0];
string task = "";
if (components.Length > 1)
task = components[1];
string[] taskAsParameter = task.Split(new Char[] { ' ' });
switch (command.ToLower())
{
case COMMAND_START_ALLMEASUREMENTS:
{
InfluenceModel infMod = new InfluenceModel(GlobalState.varModel, GlobalState.currentNFP);
List<Configuration> configurations_Learning = new List<Configuration>();
foreach (Configuration config in GlobalState.allMeasurements.Configurations)
{
if (config.nfpValues.ContainsKey(GlobalState.currentNFP))
configurations_Learning.Add(config);
}
if (configurations_Learning.Count == 0)
{
GlobalState.logInfo.logLine("The learning set is empty! Cannot start learning!");
break;
}
GlobalState.logInfo.logLine("Learning: " + "NumberOfConfigurationsLearning:" + configurations_Learning.Count);
// prepare the machine learning
exp = new MachineLearning.Learning.Regression.Learning(configurations_Learning, configurations_Learning);
exp.metaModel = infMod;
exp.mLsettings = this.mlSettings;
exp.learn();
}
break;
case COMMAND_TRUEMODEL:
StreamReader readModel = new StreamReader(task);
String model = readModel.ReadLine().Trim();
readModel.Close();
this.trueModel = new InfluenceFunction(model.Replace(',', '.'), GlobalState.varModel);
NFProperty artificalProp = new NFProperty("artificial");
GlobalState.currentNFP = artificalProp;
//computeEvaluationDataSetBasedOnTrueModel();
break;
case COMMAND_SUBSCRIPT:
{
FileInfo fi = new FileInfo(task);
StreamReader reader = null;
if (!fi.Exists)
throw new FileNotFoundException(@"Automation script not found. ", fi.ToString());
reader = fi.OpenText();
Commands co = new Commands();
co.exp = this.exp;
while (!reader.EndOfStream)
{
String oneLine = reader.ReadLine().Trim();
co.performOneCommand(oneLine);
}
}
break;
case COMMAND_EVALUATION_SET:
{
GlobalState.evalutionSet.Configurations = ConfigurationReader.readConfigurations(task, GlobalState.varModel);
GlobalState.logInfo.logLine("Evaluation set loaded.");
}
break;
case COMMAND_CLEAR_GLOBAL:
SPLConqueror_Core.GlobalState.clear();
toSample.Clear();
toSampleValidation.Clear();
break;
case COMMAND_CLEAR_SAMPLING:
exp.clearSampling();
toSample.Clear();
toSampleValidation.Clear();
break;
case COMMAND_CLEAR_LEARNING:
exp.clear();
toSample.Clear();
toSampleValidation.Clear();
break;
case COMMAND_LOAD_CONFIGURATIONS:
GlobalState.allMeasurements.Configurations = (GlobalState.allMeasurements.Configurations.Union(ConfigurationReader.readConfigurations(task, GlobalState.varModel))).ToList();
GlobalState.logInfo.logLine(GlobalState.allMeasurements.Configurations.Count + " configurations loaded.");
break;
case COMMAND_SAMPLE_ALLBINARY:
{
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
this.toSampleValidation.Add(SamplingStrategies.ALLBINARY);
this.exp.info.binarySamplings_Validation = "ALLBINARY";
}
else
{
this.toSample.Add(SamplingStrategies.ALLBINARY);
this.exp.info.binarySamplings_Learning = "ALLBINARY";
}
break;
}
case COMMAND_ANALYZE_LEARNING:
{//TODO: Analyzation is not supported in the case of bagging
GlobalState.logInfo.logLine("Models:");
if (this.mlSettings.bagging)
{
for (int i = 0; i < this.exp.models.Count; i++)
{
FeatureSubsetSelection learnedModel = exp.models[i];
if (learnedModel == null)
{
GlobalState.logError.logLine("Error... learning was not performed!");
break;
}
GlobalState.logInfo.logLine("Termination reason: " + learnedModel.LearningHistory.Last().terminationReason);
foreach (LearningRound lr in learnedModel.LearningHistory)
{
double relativeError = 0;
if (GlobalState.evalutionSet.Configurations.Count > 0)
{
double relativeErro2r = learnedModel.computeError(lr.FeatureSet, GlobalState.evalutionSet.Configurations, out relativeError);
}
else
{
double relativeErro2r = learnedModel.computeError(lr.FeatureSet, GlobalState.allMeasurements.Configurations, out relativeError);
}
GlobalState.logInfo.logLine(lr.ToString() + relativeError);
}
}
}
else
{
FeatureSubsetSelection learnedModel = exp.models[0];
if (learnedModel == null)
{
GlobalState.logError.logLine("Error... learning was not performed!");
break;
}
GlobalState.logInfo.logLine("Termination reason: " + learnedModel.LearningHistory.Last().terminationReason);
foreach (LearningRound lr in learnedModel.LearningHistory)
{
double relativeError = 0;
if (GlobalState.evalutionSet.Configurations.Count > 0)
{
double relativeErro2r = learnedModel.computeError(lr.FeatureSet, GlobalState.evalutionSet.Configurations, out relativeError);
}
else
{
double relativeErro2r = learnedModel.computeError(lr.FeatureSet, GlobalState.allMeasurements.Configurations, out relativeError);
}
GlobalState.logInfo.logLine(lr.ToString() + relativeError);
}
}
break;
}
case COMMAND_EXERIMENTALDESIGN:
performOneCommand_ExpDesign(task);
break;
case COMMAND_SAMPLING_OPTIONORDER:
parseOptionOrder(task);
break;
case COMMAND_VARIABILITYMODEL:
GlobalState.varModel = VariabilityModel.loadFromXML(task);
if (GlobalState.varModel == null)
GlobalState.logError.logLine("No variability model found at " + task);
break;
case COMMAND_SET_NFP:
GlobalState.currentNFP = GlobalState.getOrCreateProperty(task.Trim());
break;
case COMMAND_SAMPLE_OPTIONWISE:
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
this.toSampleValidation.Add(SamplingStrategies.OPTIONWISE);
this.exp.info.binarySamplings_Validation = "OPTIONSWISE";
}
else
{
this.toSample.Add(SamplingStrategies.OPTIONWISE);
this.exp.info.binarySamplings_Learning = "OPTIONSWISE";
}
break;
case COMMAND_LOG:
string location = task.Trim();
GlobalState.logInfo.close();
GlobalState.logInfo = new InfoLogger(location);
GlobalState.logError.close();
GlobalState.logError = new ErrorLogger(location + "_error");
break;
case COMMAND_SET_MLSETTING:
this.mlSettings = ML_Settings.readSettings(task);
break;
case COMMAND_LOAD_MLSETTINGS:
this.mlSettings = ML_Settings.readSettingsFromFile(task);
break;
case COMMAND_SAMPLE_PAIRWISE:
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
this.toSampleValidation.Add(SamplingStrategies.PAIRWISE);
this.exp.info.binarySamplings_Validation = "PAIRWISE";
}
else
{
this.toSample.Add(SamplingStrategies.PAIRWISE);
this.exp.info.binarySamplings_Learning = "PAIRWISE";
}
break;
case COMMAND_PRINT_MLSETTINGS:
GlobalState.logInfo.logLine(this.mlSettings.ToString());
break;
case COMMAND_PRINT_CONFIGURATIONS:
{
/* List<Dictionary<NumericOption, double>> numericSampling = exp.NumericSelection_Learning;
List<List<BinaryOption>> binarySampling = exp.BinarySelections_Learning;
List<Configuration> configurations = new List<Configuration>();
foreach (Dictionary<NumericOption, double> numeric in numericSampling)
{
foreach (List<BinaryOption> binary in binarySampling)
{
Configuration config = Configuration.getConfiguration(binary, numeric);
if (!configurations.Contains(config) && GlobalState.varModel.configurationIsValid(config))
{
configurations.Add(config);
}
}
}*/
var configs = ConfigurationBuilder.buildConfigs(GlobalState.varModel, this.toSample);
string[] para = task.Split(new char[] { ' ' });
// TODO very error prone..
ConfigurationPrinter printer = new ConfigurationPrinter(para[0], para[1], para[2], GlobalState.optionOrder);
printer.print(configs);
break;
}
case COMMAND_SAMPLE_BINARY_RANDOM:
{
string[] para = task.Split(new char[] { ' ' });
ConfigurationBuilder.binaryThreshold = Convert.ToInt32(para[0]);
ConfigurationBuilder.binaryModulu = Convert.ToInt32(para[1]);
VariantGenerator vg = new VariantGenerator(null);
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
this.toSampleValidation.Add(SamplingStrategies.BINARY_RANDOM);
this.exp.info.binarySamplings_Validation = "BINARY_RANDOM";
}
else
{
this.toSample.Add(SamplingStrategies.BINARY_RANDOM);
this.exp.info.binarySamplings_Learning = "BINARY_RANDOM " + task;
}
break;
}
case COMMAND_START_LEARNING:
{
InfluenceModel infMod = new InfluenceModel(GlobalState.varModel, GlobalState.currentNFP);
List<Configuration> configurationsLearning = buildSet(this.toSample);
List<Configuration> configurationsValidation = buildSet(this.toSampleValidation);
if (configurationsLearning.Count == 0)
{
configurationsLearning = configurationsValidation;
}
if (configurationsLearning.Count == 0)
{
GlobalState.logInfo.logLine("The learning set is empty! Cannot start learning!");
break;
}
if (configurationsValidation.Count == 0)
{
configurationsValidation = configurationsLearning;
}
GlobalState.logInfo.logLine("Learning: " + "NumberOfConfigurationsLearning:" + configurationsLearning.Count + " NumberOfConfigurationsValidation:" + configurationsValidation.Count);
//+ " UnionNumberOfConfigurations:" + (configurationsLearning.Union(configurationsValidation)).Count()); too costly to compute
// We have to reuse the list of models because of NotifyCollectionChangedEventHandlers that might be attached to the list of models.
exp.models.Clear();
var mod = exp.models;
exp = new MachineLearning.Learning.Regression.Learning(configurationsLearning, configurationsValidation);
exp.models = mod;
exp.metaModel = infMod;
exp.mLsettings = this.mlSettings;
exp.learn();
GlobalState.logInfo.logLine("Average model: \n" + exp.metaModel.printModelAsFunction());
double relativeError = 0;
if (GlobalState.evalutionSet.Configurations.Count > 0)
{
relativeError = FeatureSubsetSelection.computeError(exp.metaModel, GlobalState.evalutionSet.Configurations, ML_Settings.LossFunction.RELATIVE);
}
else
{
relativeError = FeatureSubsetSelection.computeError(exp.metaModel, GlobalState.allMeasurements.Configurations, ML_Settings.LossFunction.RELATIVE);
}
GlobalState.logInfo.logLine("Error :" + relativeError);
}
break;
case COMMAND_SAMPLE_NEGATIVE_OPTIONWISE:
// TODO there are two different variants in generating NegFW configurations.
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
this.toSampleValidation.Add(SamplingStrategies.NEGATIVE_OPTIONWISE);
this.exp.info.binarySamplings_Validation = "NEGATIVE_OPTIONWISE";
}
else
{
this.toSample.Add(SamplingStrategies.NEGATIVE_OPTIONWISE);
this.exp.info.binarySamplings_Learning = "NEGATIVE_OPTIONWISE";
}
break;
default:
return command;
}
return "";
}
/// <summary>
/// Performs the functionality of one command. If no functionality is found for the command, the command is retuned by this method.
/// </summary>
/// <param name="line">One command with its parameters.</param>
/// <returns>Returns an empty string if the command could be performed by the method. If the command could not be performed by the method, the original command is returned.</returns>
public string performOneCommand(string line)
{
GlobalState.logInfo.log(COMMAND + line);
// remove comment part of the line (the comment starts with an #)
line = line.Split(new Char[] { '#' }, 2)[0];
if (line.Length == 0)
return "";
// split line in command and parameters of the command
string[] components = line.Split(new Char[] { ' ' }, 2);
string command = components[0];
string task = "";
if (components.Length > 1)
task = components[1];
string[] taskAsParameter = task.Split(new Char[] { ' ' });
switch (command.ToLower())
{
case COMMAND_TRUEMODEL:
StreamReader readModel = new StreamReader(task);
String model = readModel.ReadLine().Trim();
readModel.Close();
exp.TrueModel = new InfluenceFunction(model.Replace(',','.'), GlobalState.varModel);
NFProperty artificalProp = new NFProperty("artificial");
GlobalState.currentNFP = artificalProp;
computeEvaluationDataSetBasedOnTrueModel();
break;
case COMMAND_SUBSCRIPT:
{
FileInfo fi = new FileInfo(task);
StreamReader reader = null;
if (!fi.Exists)
throw new FileNotFoundException(@"Automation script not found. ", fi.ToString());
reader = fi.OpenText();
Commands co = new Commands();
co.exp = this.exp;
while (!reader.EndOfStream)
{
String oneLine = reader.ReadLine().Trim();
co.performOneCommand(oneLine);
}
}
break;
case COMMAND_EVALUATION_SET:
{
GlobalState.evalutionSet.Configurations = ConfigurationReader.readConfigurations(task, GlobalState.varModel);
GlobalState.logInfo.log("Evaluation set loaded.");
}
break;
case COMMAND_CLEAR_GLOBAL:
SPLConqueror_Core.GlobalState.clear();
break;
case COMMAND_CLEAR_SAMPLING:
exp.clearSampling();
break;
case COMMAND_CLEAR_LEARNING:
exp.clear();
break;
case COMMAND_LOAD_CONFIGURATIONS:
GlobalState.allMeasurements.Configurations = (GlobalState.allMeasurements.Configurations.Union(ConfigurationReader.readConfigurations(task, GlobalState.varModel))).ToList();
GlobalState.logInfo.log(GlobalState.allMeasurements.Configurations.Count + " configurations loaded.");
break;
case COMMAND_SAMPLE_ALLBINARY:
{
VariantGenerator vg = new VariantGenerator(null);
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
exp.addBinarySelection_Validation(vg.generateAllVariantsFast(GlobalState.varModel));
exp.addBinarySampling_Validation(COMMAND_SAMPLE_ALLBINARY);
}
else
{
exp.addBinarySelection_Learning(vg.generateAllVariantsFast(GlobalState.varModel));
exp.addBinarySampling_Learning(COMMAND_SAMPLE_ALLBINARY);
}
break;
}
case COMMAND_ANALYZE_LEARNING:
{
GlobalState.logInfo.log("Models:");
FeatureSubsetSelection learning = exp.learning;
if (learning == null)
{
GlobalState.logError.log("Error... learning was not performed!");
break;
}
foreach (LearningRound lr in learning.LearningHistory)
{
double relativeError = 0;
if (GlobalState.evalutionSet.Configurations.Count > 0)
{
double relativeErro2r = exp.learning.computeError(lr.FeatureSet, GlobalState.evalutionSet.Configurations, out relativeError);
}
else
{
double relativeErro2r = exp.learning.computeError(lr.FeatureSet, GlobalState.allMeasurements.Configurations, out relativeError);
}
GlobalState.logInfo.log(lr.ToString() + relativeError);
}
break;
}
case COMMAND_EXERIMENTALDESIGN:
performOneCommand_ExpDesign(task);
break;
case COMMAND_SAMPLING_OPTIONORDER:
parseOptionOrder(task);
break;
case COMMAND_VARIABILITYMODEL:
GlobalState.varModel = VariabilityModel.loadFromXML(task);
if (GlobalState.varModel == null)
GlobalState.logError.log("No variability model found at " + task);
break;
case COMMAND_SET_NFP:
GlobalState.currentNFP = GlobalState.getOrCreateProperty(task.Trim());
break;
case COMMAND_SAMPLE_OPTIONWISE:
FeatureWise fw = new FeatureWise();
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
exp.addBinarySelection_Validation(fw.generateFeatureWiseConfigsCSP(GlobalState.varModel));
exp.addBinarySampling_Validation("FW");
}
else
{
//exp.addBinarySelection_Learning(fw.generateFeatureWiseConfigsCSP(GlobalState.varModel));
exp.addBinarySelection_Learning(fw.generateFeatureWiseConfigurations(GlobalState.varModel));
exp.addBinarySampling_Learning("FW");
}
break;
case COMMAND_LOG:
string location = task.Trim();
GlobalState.logInfo.close();
GlobalState.logInfo = new InfoLogger(location);
GlobalState.logError.close();
GlobalState.logError = new ErrorLogger(location + "_error");
break;
case COMMAND_SET_MLSETTING:
exp.mlSettings = ML_Settings.readSettings(task);
break;
case COMMAND_LOAD_MLSETTINGS:
exp.mlSettings = ML_Settings.readSettingsFromFile(task);
break;
case COMMAND_SAMPLE_PAIRWISE:
PairWise pw = new PairWise();
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
exp.addBinarySelection_Validation(pw.generatePairWiseVariants(GlobalState.varModel));
exp.addBinarySampling_Validation("PW");
}
else
{
exp.addBinarySelection_Learning(pw.generatePairWiseVariants(GlobalState.varModel));
exp.addBinarySampling_Learning("PW");
}
break;
case COMMAND_PRINT_MLSETTINGS:
GlobalState.logInfo.log(exp.mlSettings.ToString());
break;
case COMMAND_PRINT_CONFIGURATIONS:
{
List<Dictionary<NumericOption, double>> numericSampling = exp.NumericSelection_Learning;
List<List<BinaryOption>> binarySampling = exp.BinarySelections_Learning;
List<Configuration> configurations = new List<Configuration>();
foreach (Dictionary<NumericOption, double> numeric in numericSampling)
{
foreach (List<BinaryOption> binary in binarySampling)
{
Configuration config = Configuration.getConfiguration(binary, numeric);
if (!configurations.Contains(config) && GlobalState.varModel.configurationIsValid(config))
{
configurations.Add(config);
}
}
}
string[] para = task.Split(new char[] { ' ' });
// TODO very error prune..
ConfigurationPrinter printer = new ConfigurationPrinter(para[0], para[1], para[2], GlobalState.optionOrder);
printer.print(configurations);
break;
}
case COMMAND_SAMPLE_BINARY_RANDOM:
{
string[] para = task.Split(new char[] { ' ' });
int treshold = Convert.ToInt32(para[0]);
int modulu = Convert.ToInt32(para[1]);
VariantGenerator vg = new VariantGenerator(null);
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
exp.addBinarySelection_Validation(vg.generateRandomVariants(GlobalState.varModel, treshold, modulu));
exp.addBinarySampling_Validation("random " + task);
}
else
{
exp.addBinarySelection_Learning(vg.generateRandomVariants(GlobalState.varModel, treshold, modulu));
exp.addBinarySampling_Learning("random " + task);
}
break;
}
case COMMAND_START_LEARNING:
{
InfluenceModel infMod = new InfluenceModel(GlobalState.varModel, GlobalState.currentNFP);
List<Configuration> configurations_Learning = new List<Configuration>();
List<Configuration> configurations_Validation = new List<Configuration>();
if (exp.TrueModel == null)
{
//List<List<BinaryOption>> availableBinary
//configurations_Learning = GlobalState.getMeasuredConfigs(exp.BinarySelections_Learning, exp.NumericSelection_Learning);
configurations_Learning = GlobalState.getMeasuredConfigs(Configuration.getConfigurations(exp.BinarySelections_Learning, exp.NumericSelection_Learning));
configurations_Learning = configurations_Learning.Distinct().ToList();
configurations_Validation = GlobalState.getMeasuredConfigs(Configuration.getConfigurations(exp.BinarySelections_Validation, exp.NumericSelection_Validation));
configurations_Validation = configurations_Validation.Distinct().ToList();
//break;//todo only to get the configurations that we haven't measured
} else
{
foreach (List<BinaryOption> binConfig in exp.BinarySelections_Learning)
{
if (exp.NumericSelection_Learning.Count == 0)
{
Configuration c = new Configuration(binConfig);
c.setMeasuredValue(GlobalState.currentNFP, exp.TrueModel.eval(c));
if (!configurations_Learning.Contains(c))
configurations_Learning.Add(c);
continue;
}
foreach (Dictionary<NumericOption, double> numConf in exp.NumericSelection_Learning)
{
Configuration c = new Configuration(binConfig, numConf);
c.setMeasuredValue(GlobalState.currentNFP, exp.TrueModel.eval(c));
if(GlobalState.varModel.configurationIsValid(c))
// if (!configurations_Learning.Contains(c))
configurations_Learning.Add(c);
}
}
}
if (configurations_Learning.Count == 0)
{
configurations_Learning = configurations_Validation;
}
if (configurations_Learning.Count == 0)
{
GlobalState.logInfo.log("The learning set is empty! Cannot start learning!");
break;
}
if (configurations_Validation.Count == 0)
{
configurations_Validation = configurations_Learning;
}
//break;
GlobalState.logInfo.log("Learning: " + "NumberOfConfigurationsLearning:" + configurations_Learning.Count + " NumberOfConfigurationsValidation:" + configurations_Validation.Count
+ " UnionNumberOfConfigurations:" + (configurations_Learning.Union(configurations_Validation)).Count());
// prepare the machine learning
exp.learning.init(infMod, exp.mlSettings);
exp.learning.setLearningSet(configurations_Learning);
exp.learning.setValidationSet(configurations_Validation);
exp.learning.learn();
}
break;
case COMMAND_SAMPLE_NEGATIVE_OPTIONWISE:
// TODO there are two different variants in generating NegFW configurations.
NegFeatureWise neg = new NegFeatureWise();
if (taskAsParameter.Contains(COMMAND_VALIDATION))
{
exp.addBinarySelection_Validation(neg.generateNegativeFW(GlobalState.varModel));
exp.addBinarySampling_Validation("newFW");
}
else
{
exp.addBinarySelection_Learning(neg.generateNegativeFW(GlobalState.varModel));//neg.generateNegativeFWAllCombinations(GlobalState.varModel));
exp.addBinarySampling_Learning("newFW");
}
break;
default:
return command;
}
return "";
}
/// <summary>
/// The methods generates based on all binary sampling and 50% hyper sampling configurations for the validation set.
/// If we have the true model, we can just compute the true value of the nonfunctional property for a given configuration.
/// </summary>
private void computeEvaluationDataSetBasedOnTrueModel()
{
VariantGenerator vg = new VariantGenerator(null);
List<List<BinaryOption>> temp = vg.generateAllVariantsFast(GlobalState.varModel);
List<List<BinaryOption>> binaryConfigs = new List<List<BinaryOption>>();
//take only 10k
if (temp.Count > 1000)
{
GlobalState.logInfo.log("Found " + temp.Count + " configurations. Use only 1000.");
HashSet<int> picked = new HashSet<int>();
Random r = new Random(1);
for (int i = 0; i < 1000; i++)
{
int x = 0;
do
{
x = r.Next(1, temp.Count);
} while (picked.Contains(x));
picked.Add(x);
binaryConfigs.Add(temp[x]);
}
temp.Clear();
}
else
binaryConfigs = temp;
exp.addBinarySelection_Validation(binaryConfigs);
var expDesign = new HyperSampling(GlobalState.varModel.NumericOptions);
expDesign.Precision = 10;
expDesign.computeDesign();
exp.addNumericalSelection_Validation(expDesign.SelectedConfigurations);
var numericConfigs = expDesign.SelectedConfigurations;
foreach (List<BinaryOption> binConfig in binaryConfigs)
{
if (numericConfigs.Count == 0)
{
Configuration c = new Configuration(binConfig);
c.setMeasuredValue(GlobalState.currentNFP, exp.TrueModel.eval(c));
GlobalState.addConfiguration(c);
}
foreach (Dictionary<NumericOption, double> numConf in numericConfigs)
{
Configuration c = new Configuration(binConfig, numConf);
c.setMeasuredValue(GlobalState.currentNFP, exp.TrueModel.eval(c));
GlobalState.addConfiguration(c);
}
}
}
public static List<Configuration> buildConfigs(VariabilityModel vm, List<SamplingStrategies> strategies)
{
List<Configuration> result = new List<Configuration>();
VariantGenerator vg = new VariantGenerator(null);
ExperimentalDesign design = null;
List<List<BinaryOption>> binaryConfigs = new List<List<BinaryOption>>();
List<Dictionary<NumericOption, Double>> numericConfigs = new List<Dictionary<NumericOption, double>>();
foreach (SamplingStrategies strat in strategies)
{
switch (strat)
{
//Binary sampling heuristics
case SamplingStrategies.ALLBINARY:
binaryConfigs.AddRange(vg.generateAllVariantsFast(vm));
break;
case SamplingStrategies.BINARY_RANDOM:
binaryConfigs.AddRange(vg.generateRandomVariants(GlobalState.varModel, binaryThreshold, binaryModulu));
break;
case SamplingStrategies.OPTIONWISE:
FeatureWise fw = new FeatureWise();
binaryConfigs.AddRange(fw.generateFeatureWiseConfigurations(GlobalState.varModel));
break;
case SamplingStrategies.PAIRWISE:
PairWise pw = new PairWise();
binaryConfigs.AddRange(pw.generatePairWiseVariants(GlobalState.varModel));
break;
case SamplingStrategies.NEGATIVE_OPTIONWISE:
NegFeatureWise neg = new NegFeatureWise();//2nd option: neg.generateNegativeFWAllCombinations(GlobalState.varModel));
binaryConfigs.AddRange(neg.generateNegativeFW(GlobalState.varModel));
break;
//Experimental designs for numeric options
case SamplingStrategies.BOXBEHNKEN:
if (optionsToConsider.ContainsKey(SamplingStrategies.BOXBEHNKEN))
design = new BoxBehnkenDesign(optionsToConsider[SamplingStrategies.BOXBEHNKEN]);
else
design = new BoxBehnkenDesign(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.BOXBEHNKEN])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.CENTRALCOMPOSITE:
if (optionsToConsider.ContainsKey(SamplingStrategies.CENTRALCOMPOSITE))
design = new CentralCompositeInscribedDesign(optionsToConsider[SamplingStrategies.CENTRALCOMPOSITE]);
else
design = new CentralCompositeInscribedDesign(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.CENTRALCOMPOSITE])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.FULLFACTORIAL:
if (optionsToConsider.ContainsKey(SamplingStrategies.FULLFACTORIAL))
design = new FullFactorialDesign(optionsToConsider[SamplingStrategies.FULLFACTORIAL]);
else
design = new FullFactorialDesign(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.FULLFACTORIAL])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.HYPERSAMPLING:
if (optionsToConsider.ContainsKey(SamplingStrategies.HYPERSAMPLING))
design = new HyperSampling(optionsToConsider[SamplingStrategies.HYPERSAMPLING]);
else
design = new HyperSampling(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.HYPERSAMPLING])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.ONEFACTORATATIME:
if (optionsToConsider.ContainsKey(SamplingStrategies.ONEFACTORATATIME))
design = new OneFactorAtATime(optionsToConsider[SamplingStrategies.ONEFACTORATATIME]);
else
design = new OneFactorAtATime(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.ONEFACTORATATIME])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.KEXCHANGE:
if (optionsToConsider.ContainsKey(SamplingStrategies.KEXCHANGE))
design = new KExchangeAlgorithm(optionsToConsider[SamplingStrategies.KEXCHANGE]);
else
design = new KExchangeAlgorithm(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.KEXCHANGE])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.PLACKETTBURMAN:
if (optionsToConsider.ContainsKey(SamplingStrategies.PLACKETTBURMAN))
design = new PlackettBurmanDesign(optionsToConsider[SamplingStrategies.PLACKETTBURMAN]);
else
design = new PlackettBurmanDesign(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.PLACKETTBURMAN])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
case SamplingStrategies.RANDOM:
if (optionsToConsider.ContainsKey(SamplingStrategies.RANDOM))
design = new RandomSampling(optionsToConsider[SamplingStrategies.RANDOM]);
else
design = new RandomSampling(vm.NumericOptions);
foreach (Dictionary<string, string> expDesignParamSet in parametersOfExpDesigns[SamplingStrategies.RANDOM])
{
design.computeDesign(expDesignParamSet);
numericConfigs.AddRange(design.SelectedConfigurations);
}
break;
}
}
foreach (List<BinaryOption> binConfig in binaryConfigs)
{
if (numericConfigs.Count == 0)
{
Configuration c = new Configuration(binConfig);
result.Add(c);
}
foreach (Dictionary<NumericOption, double> numConf in numericConfigs)
{
Configuration c = new Configuration(binConfig, numConf);
result.Add(c);
}
}
return result.Distinct().ToList();
}
