public void ExtractActiveParametersThrowsForParametersNull()
{
var specification = new ParameterConfigurationSpaceSpecification(
new List <IParameterNode> {
new ValueNode <double>("a", new ContinuousDomain())
},
new Dictionary <string, List <EqualsCondition> >(),
new List <ForbiddenParameterCombination>());
Assert.Throws <ArgumentNullException>(() => specification.ExtractActiveParameters(parameters: null));
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterConfigurationSpaceGenomeBuilderTest"/> class.
/// </summary>
public ParameterConfigurationSpaceGenomeBuilderTest()
{
this._parameterSpecification = ParameterConfigurationSpaceGenomeBuilderTest.CreateParameterConfigurationSpaceSpecification();
this._parameterTree = AcLibUtils.CreateParameterTree(this._parameterSpecification);
this._genomeBuilder = new ParameterConfigurationSpaceGenomeBuilder(
this._parameterTree,
this._parameterSpecification,
this._configuration);
Randomizer.Reset();
Randomizer.Configure();
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterConfigurationSpaceGenomeBuilder"/> class.
/// </summary>
/// <param name="parameterTree">The parameters' structure.</param>
/// <param name="parameterSpecification">
/// A specification defining forbidden parameter combinations and activity conditions.
/// </param>
/// <param name="configuration">Configuration parameters.</param>
public ParameterConfigurationSpaceGenomeBuilder(
ParameterTree parameterTree,
ParameterConfigurationSpaceSpecification parameterSpecification,
AlgorithmTunerConfiguration configuration)
: base(parameterTree, configuration)
{
this._parameterTree = parameterTree;
this._parameterSpecification = parameterSpecification ??
throw new ArgumentNullException(nameof(parameterSpecification));
this._identifierToTreeNode =
this._parameterTree.GetParameters().ToDictionary(node => node.Identifier, node => node);
}
public void MakeGenomeValidOnlyChangesRelevantParameters()
{
// Create a specification with several parameters.
var parameters = new List <IParameterNode>
{
new ValueNode <int>("a", new IntegerDomain(-2, 4)),
new ValueNode <int>("Forbidden", new IntegerDomain(-30, 60)),
new ValueNode <int>("c", new IntegerDomain(-2, 4)),
};
var forbiddenValue = new Dictionary <string, IAllele> {
{ "Forbidden", new Allele <int>(0) }
};
var inactiveForbiddenValue = new Dictionary <string, IAllele> {
{ "a", new Allele <int>(2) }
};
var forbiddenCombinations = new List <ForbiddenParameterCombination>
{
new ForbiddenParameterCombination(inactiveForbiddenValue),
new ForbiddenParameterCombination(forbiddenValue),
};
var multipleParameterSpecification = new ParameterConfigurationSpaceSpecification(
parameters,
new Dictionary <string, List <EqualsCondition> >(),
forbiddenCombinations);
this._genomeBuilder = new ParameterConfigurationSpaceGenomeBuilder(
AcLibUtils.CreateParameterTree(multipleParameterSpecification),
multipleParameterSpecification,
this._configuration);
// Several times:
int numberTests = 20;
for (int i = 0; i < numberTests; i++)
{
// Create an invalid genome.
var genome = new Genome();
genome.SetGene("a", new Allele <int>(-1));
genome.SetGene("Forbidden", new Allele <int>(0));
genome.SetGene("c", new Allele <int>(2));
// Repair it.
this._genomeBuilder.MakeGenomeValid(genome);
// Check it is repaired with only the forbidden value changed.
Assert.NotEqual(
0,
genome.GetGeneValue("Forbidden").GetValue());
Assert.Equal(-1, genome.GetGeneValue("a").GetValue());
Assert.Equal(2, genome.GetGeneValue("c").GetValue());
}
}
public void ExtractActiveParametersRemovesInactiveParameters()
{
var parameters = new List <IParameterNode>
{
new ValueNode <int>("unconditional", new IntegerDomain()),
new ValueNode <double>("unconditional_2", new ContinuousDomain()),
new ValueNode <int>("conditions_met", new IntegerDomain()),
new ValueNode <int>("one_condition_met", new IntegerDomain()),
};
var conditionsMet = new List <EqualsCondition>
{
new EqualsCondition("unconditional", new IAllele[] { new Allele <int>(214) }),
new EqualsCondition("unconditional_2", new IAllele[] { new Allele <double>(-4) }),
};
var oneConditionMet = new List <EqualsCondition>
{
new EqualsCondition("unconditional", new IAllele[] { new Allele <int>(214) }),
new EqualsCondition("unconditional_2", new IAllele[] { new Allele <double>(-8) }),
};
var specification = new ParameterConfigurationSpaceSpecification(
parameters,
new Dictionary <string, List <EqualsCondition> > {
{ "conditions_met", conditionsMet }, { "one_condition_met", oneConditionMet }
},
new List <ForbiddenParameterCombination>());
var parameterValues = new Dictionary <string, IAllele>
{
["unconditional"] = new Allele <int>(214),
["unconditional_2"] = new Allele <double>(-4),
["conditions_met"] = new Allele <int>(24),
["one_condition_met"] = new Allele <int>(23),
};
var activeParameters = specification.ExtractActiveParameters(parameterValues);
Assert.Equal(
3,
activeParameters.Count);
foreach (var expectedParameter in parameterValues.Where(p => !Equals("one_condition_met", p.Key)))
{
if (!activeParameters.TryGetValue(expectedParameter.Key, out var activeValue))
{
Assert.True(false, $"{expectedParameter.Key} should be active.");
}
Assert.Equal(
expectedParameter.Value,
activeValue);
}
}
/// <summary>
/// Creates a flat <see cref="ParameterTree"/> using the specified configuration.
/// </summary>
/// <param name="parameterConfiguration">The parameter configuration.</param>
/// <returns>The created <see cref="ParameterTree"/>.</returns>
public static ParameterTree CreateParameterTree(ParameterConfigurationSpaceSpecification parameterConfiguration)
{
if (parameterConfiguration == null)
{
throw new ArgumentNullException(nameof(parameterConfiguration));
}
var root = new AndNode();
foreach (var parameter in parameterConfiguration.Parameters)
{
root.AddChild(parameter);
}
return(new ParameterTree(root));
}
public void MakeGenomeValidCanHandleMultipleIssues()
{
// Create a specification with dependent rules.
var parameters = new List <IParameterNode>
{
new ValueNode <int>("a", new IntegerDomain(-2, 4)),
new ValueNode <int>("Forbidden", new CategoricalDomain <int>(new List <int> {
6, 89
})),
new ValueNode <int>("c", new IntegerDomain(-2, 4)),
};
var forbiddenValue = new Dictionary <string, IAllele> {
{ "Forbidden", new Allele <int>(6) }
};
var dependentRule = new Dictionary <string, IAllele> {
{ "a", new Allele <int>(2) }, { "Forbidden", new Allele <int>(89) }
};
var forbiddenCombinations = new List <ForbiddenParameterCombination>
{
new ForbiddenParameterCombination(dependentRule),
new ForbiddenParameterCombination(forbiddenValue),
};
var multipleParameterSpecification = new ParameterConfigurationSpaceSpecification(
parameters,
new Dictionary <string, List <EqualsCondition> >(),
forbiddenCombinations);
this._genomeBuilder = new ParameterConfigurationSpaceGenomeBuilder(
AcLibUtils.CreateParameterTree(multipleParameterSpecification),
multipleParameterSpecification,
this._configuration);
// Create an genome which is invalid and needs at least two mutations to get valid.
var genome = new Genome();
genome.SetGene("a", new Allele <int>(2));
genome.SetGene("Forbidden", new Allele <int>(6));
genome.SetGene("c", new Allele <int>(-1));
this._genomeBuilder.MakeGenomeValid(genome);
Assert.Equal(89, genome.GetGeneValue("Forbidden").GetValue());
Assert.NotEqual(2, genome.GetGeneValue("a").GetValue());
Assert.Equal(-1, genome.GetGeneValue("c").GetValue());
}
GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> BuildRuntimeTuner(
ParameterTree parameterTree,
Scenario scenario,
ParameterConfigurationSpaceSpecification parameterSpecification,
IEnumerable <InstanceSeedFile> trainingInstances,
IEnumerable <InstanceSeedFile> testInstances,
AlgorithmTunerConfiguration configuration)
{
LoggingHelper.WriteLine(VerbosityLevel.Info, $"Tuning '{scenario.Command}' for PAR-{scenario.PenalizationFactor}.");
var runtimeTuner =
new AlgorithmTuner <RuntimeRunner, InstanceSeedFile, RuntimeResult, StandardRandomForestLearner <ReuseOldTreesStrategy>,
GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy>(
targetAlgorithmFactory: new RuntimeRunnerFactory(scenario, parameterSpecification),
runEvaluator: new SortByPenalizedRuntime <InstanceSeedFile>(scenario.PenalizationFactor, configuration.CpuTimeout),
trainingInstances: trainingInstances,
parameterTree: parameterTree,
configuration: configuration,
genomeBuilder: new ParameterConfigurationSpaceGenomeBuilder(parameterTree, parameterSpecification, configuration));
runtimeTuner.SetTestInstances(testInstances);
return(runtimeTuner);
}
GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> BuildValueTuner(
ParameterTree parameterTree,
Scenario scenario,
ParameterConfigurationSpaceSpecification parameterSpecification,
IEnumerable <InstanceSeedFile> trainingInstances,
IEnumerable <InstanceSeedFile> testInstances,
AlgorithmTunerConfiguration configuration)
{
LoggingHelper.WriteLine(VerbosityLevel.Info, $"Tuning '{scenario.Command}' for minimum cost.");
var qualityTuner =
new AlgorithmTuner <QualityRunner, InstanceSeedFile, ContinuousResult, StandardRandomForestLearner <ReuseOldTreesStrategy>,
GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy>(
targetAlgorithmFactory: new QualityRunnerFactory(scenario, parameterSpecification),
runEvaluator: new SortByValue <InstanceSeedFile>(ascending: true),
trainingInstances: trainingInstances,
parameterTree: parameterTree,
configuration: configuration,
genomeBuilder: new ParameterConfigurationSpaceGenomeBuilder(parameterTree, parameterSpecification, configuration));
qualityTuner.SetTestInstances(testInstances);
return(qualityTuner);
}
public void MakeGenomeValidThrowsForImpossibleTasks()
{
// Create a specification in which every value is forbidden.
var parameters = new List <IParameterNode>
{
new ValueNode <int>("a", new CategoricalDomain <int>(new List <int> {
7, -12
}))
};
var forbiddenValue = new Dictionary <string, IAllele> {
{ "a", new Allele <int>(7) }
};
var secondForbidden = new Dictionary <string, IAllele> {
{ "a", new Allele <int>(-12) }
};
var forbiddenCombinations = new List <ForbiddenParameterCombination>
{
new ForbiddenParameterCombination(forbiddenValue),
new ForbiddenParameterCombination(secondForbidden),
};
var impossibleSpecification = new ParameterConfigurationSpaceSpecification(
parameters,
new Dictionary <string, List <EqualsCondition> >(),
forbiddenCombinations);
this._genomeBuilder = new ParameterConfigurationSpaceGenomeBuilder(
AcLibUtils.CreateParameterTree(impossibleSpecification),
impossibleSpecification,
this._configuration);
// Try to repair a genome.
var genome = new Genome();
genome.SetGene("a", new Allele <int>(7));
Assert.Throws <TimeoutException>(() => this._genomeBuilder.MakeGenomeValid(genome));
}
public void CreateParameterTreeCreatesFlatTree()
{
var parameters = new List <IParameterNode>
{
new ValueNode <string>("a", new CategoricalDomain <string>(new List <string> {
"0", "1"
})),
new ValueNode <int>("b", new DiscreteLogDomain(1, 1024)),
new ValueNode <double>("c", new ContinuousDomain(-1.02, 2.6)),
};
var specification = new ParameterConfigurationSpaceSpecification(
parameters,
new Dictionary <string, List <EqualsCondition> >(),
new List <ForbiddenParameterCombination>());
var tree = AcLibUtils.CreateParameterTree(specification);
Assert.Equal(3, tree.GetParameters().Count());
foreach (var parameter in parameters)
{
Assert.True(
tree.Root.Children.Contains(parameter),
$"{parameter} was not placed directly below the parameter tree root.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RunnerFactoryBase{TTargetAlgorithm,TResult}"/>
/// class.
/// </summary>
/// <param name="scenario">The ACLib scenario.</param>
/// <param name="parameterSpecification">
/// A specification defining, among other things, parameter activity conditions.
/// </param>
protected RunnerFactoryBase(Scenario scenario, ParameterConfigurationSpaceSpecification parameterSpecification)
{
this.Scenario = scenario ?? throw new ArgumentNullException(nameof(scenario));
this._parameterSpecification = parameterSpecification ??
throw new ArgumentNullException(nameof(parameterSpecification));
}
/// <summary>
/// Initializes a new instance of the <see cref="QualityRunnerFactory"/> class.
/// </summary>
/// <param name="scenario">The ACLib scenario.</param>
/// <param name="parameterSpecification">
/// A specification defining, among other things, parameter activity conditions.
/// </param>
public QualityRunnerFactory(Scenario scenario, ParameterConfigurationSpaceSpecification parameterSpecification)
: base(scenario, parameterSpecification)
{
}
