/// <summary>
/// Dump the current state of SPLConqueror to Files.
/// </summary>
/// <param name="pathArray">Array with file paths. Needs 5 paths. Data will be stored in these files.</param>
/// <param name="mlSettings">Current ML_Settings, to save.</param>
/// <param name="toSample">Sampling strategies to save.</param>
/// <param name="toSampleValidation">Validation sampling strategies to save.</param>
/// <param name="exp">Learning object to save.</param>
/// <param name="history">Command history to save.</param>
public static void dump(string[] path, ML_Settings mlSettings, List <SamplingStrategies> toSample, List <SamplingStrategies> toSampleValidation, Learning exp, CommandHistory history)
{
if (path.Length >= 1)
{
StreamWriter sw = new StreamWriter(path[0] + "GlobalState.xml");
sw.Write(PersistGlobalState.dump());
sw.Flush();
sw.Close();
sw = new StreamWriter(path[0] + "mlSettings.xml");
sw.Write(PersistMLSettings.dump(mlSettings));
sw.Flush();
sw.Close();
sw = new StreamWriter(path[0] + "toSample.xml");
sw.Write(PersistSampling.dump(toSample));
sw.Flush();
sw.Close();
sw = new StreamWriter(path[0] + "toSampleValidation.xml");
sw.Write(PersistSampling.dump(toSampleValidation));
sw.Flush();
sw.Close();
sw = new StreamWriter(path[0] + "learning.xml");
sw.Write(PersistLearning.dump(exp));
sw.Flush();
sw.Close();
sw = new StreamWriter(path[0] + "history.xml");
sw.Write(PersistCommandHistory.dump(history));
sw.Flush();
sw.Close();
}
else
{
GlobalState.logError.logLine("Couldn't dump the data. Not all target paths are given");
}
}
protected SamplingBasedAdditionStrategy(ML_Settings mlSettings, ConfigurationBuilder configBuilder,
string sampleTask)
{
this.configBuilder = configBuilder;
this.mlSettings = mlSettings;
this.sampleTask = sampleTask;
}
/// <summary>
/// String that represents the current mlsettings to save it as persistent file.
/// </summary>
/// <returns>ML_Settings in a xml format.</returns>
public static string dump(ML_Settings mlsettings)
{
XmlSerializer xmls = new XmlSerializer(typeof(ML_Settings));
StringWriter sw = new StringWriter();
xmls.Serialize(sw, mlsettings);
return(sw.ToString().Replace("utf-16", "utf-8"));
}
private List <Configuration> buildSet(ML_Settings mlSettings, List <SamplingStrategies> binaryStrats, List <ExperimentalDesign> numericStrats, List <HybridStrategy> hybridStrats)
{
blacklisted = mlSettings.blacklisted;
List <Configuration> configurationsTest = buildConfigs(GlobalState.varModel, binaryStrats, numericStrats, hybridStrats);
configurationsTest = GlobalState.getMeasuredConfigs(configurationsTest);
return(configurationsTest);
}
public void clear()
{
this.nbBaggings = 0;
this.mLsettings = new ML_Settings();
this.metaModel = null;
this.models.Clear();
clearSampling();
}
/// <summary>
/// Recover a older ml settings from the persistent dump.
/// </summary>
/// <param name="persistentDump">Persistent ml settings dump as string</param>
/// <returns>Previous ML_Settings object</returns>
public static ML_Settings recoverFromPersistentDump(string persistentDump)
{
XmlDocument persistentMLSettings = new System.Xml.XmlDocument();
persistentMLSettings.Load(persistentDump);
XmlElement mlsettings = persistentMLSettings.DocumentElement;
StringBuilder sb = new StringBuilder();
foreach (XmlElement data in mlsettings)
{
if (data.InnerText != "" && data.InnerText.Trim().Length > 0)
{
sb.Append(data.Name + ":" + data.InnerText.Trim() + " ");
}
}
return(ML_Settings.readSettings(sb.ToString()));
}
/// <summary>
/// Constructor of the learning class. It reads all configuration options and generates candidates for possible influences (i.e., features).
/// </summary>
/// <param name="infModel">The influence model which will later hold all determined influences and contains the variability model from which we derive all configuration options.</param>
public FeatureSubsetSelection(InfluenceModel infModel, ML_Settings settings)
{
this.infModel = infModel;
this.MLsettings = settings;
foreach (var opt in infModel.Vm.BinaryOptions)
{
if (opt == infModel.Vm.Root)
{
continue;
}
initialFeatures.Add(new Feature(opt.Name, infModel.Vm));
}
this.strictlyMandatoryFeatures.Add(new Feature(infModel.Vm.Root.Name, infModel.Vm));
foreach (var opt in infModel.Vm.NumericOptions)
{
initialFeatures.Add(new Feature(opt.Name, infModel.Vm));
}
}
/// <summary>
/// Recover the SPLConqueror data from files.
/// </summary>
/// <param name="pathArray">String array with the file paths. Needs 6 file paths.</param>
/// <returns>Tuple containing all recovered data.</returns>
public static Tuple <ML_Settings, List <SamplingStrategies>, List <SamplingStrategies> > recoverDataFromDump(string[] path)
{
if (path.Length >= 1)
{
PersistGlobalState.recoverFromPersistentDump(path[0] + "GlobalState.xml");
ML_Settings mlSettings = PersistMLSettings.recoverFromPersistentDump(path[0] + "mlSettings.xml");
List <SamplingStrategies> toSample = PersistSampling.recoverFromDump(path[0] + "toSample.xml");
List <SamplingStrategies> toSampleValidation = PersistSampling.recoverFromDump(path[0] + "toSampleValidation.xml");
List <List <string> > learningRounds = PersistLearning.recoverFromPersistentDump(path[0] + "learning.xml");
learningHistory = Tuple.Create(true, learningRounds.Last());
history = PersistCommandHistory.recoverFromDump(path[0] + "history.xml");
return(Tuple.Create(mlSettings, toSample, toSampleValidation));
}
else
{
GlobalState.logError.logLine("Couldn't recover from dump. Not all source paths are given");
return(null);
}
}
/// <summary>
/// Clears the binary and numeric selections and the machine learning settings stored in this object.
/// </summary>
public void clear()
{
mlSettings = new ML_Settings();
clearSampling();
}
public MatrixMaxAdditionStrategy(ML_Settings mlSettings, ConfigurationBuilder configBuilder,
string sampleTask) : base(mlSettings, configBuilder, sampleTask)
{
}
public MostSimilarPerformanceExchangeStrategy(ML_Settings mlSettings) : base(mlSettings, 0.1)
{
}
public SimpleSamplingBasedAdditionStrategy(ML_Settings mlSettings, ConfigurationBuilder configBuilder,
string sampleTask) : base(mlSettings, configBuilder, sampleTask)
{
}
protected LargestValidationErrorExchangeStrategy(ML_Settings mlSettings, double percentageToExchange)
{
this.mlSettings = mlSettings;
this.percentageToExchange = percentageToExchange;
}
public PerformanceValueExchangeStrategy(ML_Settings mlSettings) : base(mlSettings, 0.1)
{
}
private string mlSettingsContent(ML_Settings settings)
{
return(CommandLine.Commands.COMMAND_SET_MLSETTING + " " + settings.ToString());
}
public List <Configuration> buildSetForValidation(ML_Settings mlSettings)
{
return(buildSet(mlSettings, binaryStrategiesValidation, numericStrategiesValidation, hybridStrategiesValidation));
}
public List <Configuration> buildSet(ML_Settings mlSettings)
{
return(buildSet(mlSettings, binaryStrategies, numericStrategies, hybridStrategies));
}
public Tuple <List <Configuration>, List <Configuration> > buildSetsEfficient(ML_Settings mlSettings)
{
bool measurementsValid = false;
List <Configuration> configurationsLearning;
List <Configuration> configurationsValidation;
if (isAllMeasurementsToSample() && allMeasurementsValid() && (mlSettings.blacklisted == null || mlSettings.blacklisted.Count == 0))
{
measurementsValid = true;
configurationsLearning = GlobalState.allMeasurements.Configurations;
}
else
{
configurationsLearning = buildSet(mlSettings, binaryStrategies, numericStrategies, hybridStrategies);
}
if (isAllMeasurementsValidation() && (measurementsValid || allMeasurementsValid()) && (mlSettings.blacklisted == null || mlSettings.blacklisted.Count == 0))
{
configurationsValidation = GlobalState.allMeasurements.Configurations;
}
else
{
configurationsValidation = buildSet(mlSettings, binaryStrategiesValidation, numericStrategiesValidation, hybridStrategiesValidation);
}
return(Tuple.Create(configurationsLearning, configurationsValidation));
}
public KFoldCrossValidation(ML_Settings _settings, List <Configuration> _trainingSet)
{
this.settings = _settings;
trainingSet = _trainingSet;
}
public ActiveLearning(ML_Settings mlSettings, InfluenceModel influenceModel, ConfigurationBuilder configBuilder)
{
this.mlSettings = mlSettings;
this.influenceModel = influenceModel;
this.configBuilder = configBuilder;
}
public PairwiseDistanceExchangeStrategy(ML_Settings mlSettings) : base(mlSettings, 0.1)
{
}
