/// <summary>
/// Mutates the endogenous strategy parameters.
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="vector">The strategy vector to manipulate.</param>
/// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
/// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
public static void Apply(IRandom random, RealVector vector, double generalLearningRate, double learningRate) {
NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
for (int i = 0; i < vector.Length; i++) {
vector[i] *= generalMultiplier * Math.Exp(learningRate * N.NextDouble());
}
}
/// <summary>
/// Performs an adaptive normally distributed all position manipulation on the given
/// <paramref name="vector"/>.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
/// as long as the vector to get manipulated.</exception>
/// <param name="sigma">The strategy vector determining the strength of the mutation.</param>
/// <param name="random">A random number generator.</param>
/// <param name="vector">The real vector to manipulate.</param>
/// <returns>The manipulated real vector.</returns>
public static void Apply(IRandom random, RealVector vector, RealVector sigma) {
if (sigma == null || sigma.Length == 0) throw new ArgumentException("ERROR: Vector containing the standard deviations is not defined.", "sigma");
NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
for (int i = 0; i < vector.Length; i++) {
vector[i] = vector[i] + (N.NextDouble() * sigma[i % sigma.Length]);
}
}
public static AdditiveMove[] Apply(IRandom random, RealVector vector, double sigma, int sampleSize, DoubleMatrix bounds) {
AdditiveMove[] moves = new AdditiveMove[sampleSize];
NormalDistributedRandom N = new NormalDistributedRandom(random, 0, sigma);
for (int i = 0; i < sampleSize; i++) {
int index = random.Next(vector.Length);
double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
do {
strength = N.NextDouble();
} while (vector[index] + strength < min || vector[index] + strength > max);
moves[i] = new AdditiveMove(index, strength);
}
return moves;
}
/// <summary>
/// Performs a normally distributed all position manipulation on the given
/// <paramref name="vector"/> and rounds the result to the next feasible value.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the sigma vector is null or of length 0.</exception>
/// <param name="sigma">The sigma vector determining the strength of the mutation.</param>
/// <param name="random">A random number generator.</param>
/// <param name="vector">The integer vector to manipulate.</param>#
/// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
/// <returns>The manipulated integer vector.</returns>
public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray sigma) {
if (sigma == null || sigma.Length == 0) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
var N = new NormalDistributedRandom(random, 0.0, 1.0);
for (int i = 0; i < vector.Length; i++) {
int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
int value = (vector[i] + (int)Math.Round((N.NextDouble() * sigma[i % sigma.Length])) - min) / step;
max = FloorFeasible(min, max, step, max - 1);
vector[i] = RoundFeasible(min, max, step, value);
}
}
public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
var sizes = new int[] { 50, 100, 200 };
var pp = new double[] { 0.1, 0.25, 0.5 };
var noiseRatios = new double[] { 0.01, 0.05, 0.1, 0.2 };
var mt = new MersenneTwister();
var xGenerator = new NormalDistributedRandom(mt, 0, 1);
var weightGenerator = new UniformDistributedRandom(mt, 0, 10);
return (from size in sizes
from p in pp
from noiseRatio in noiseRatios
select new FeatureSelection(size, p, noiseRatio, xGenerator, weightGenerator))
.Cast<IDataDescriptor>()
.ToList();
}
/// <summary>
/// Mutates the endogenous strategy parameters.
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="vector">The strategy vector to manipulate.</param>
/// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
/// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
/// <param name="bounds">The minimal and maximal value for each component, bounds are cycled if the length of bounds is smaller than the length of vector</param>
public static void Apply(IRandom random, DoubleArray vector, double generalLearningRate, double learningRate, DoubleMatrix bounds) {
NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
for (int i = 0; i < vector.Length; i++) {
double change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
if (bounds != null) {
double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
if (min == max) vector[i] = min;
else {
if (change < min || change > max) change = Math.Max(min, Math.Min(max, change));
vector[i] = change;
}
}
}
}
/// <summary>
/// Performs an adaptive normally distributed all position manipulation on the given
/// <paramref name="vector"/>.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
/// as long as the vector to get manipulated.</exception>
/// <param name="strategyParameters">The strategy vector determining the strength of the mutation.</param>
/// <param name="random">A random number generator.</param>
/// <param name="vector">The real vector to manipulate.</param>
/// <returns>The manipulated real vector.</returns>
public static void Apply(IRandom random, RealVector vector, RealVector strategyParameters) {
NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
if (strategyParameters != null) {
for (int i = 0; i < vector.Length; i++) {
vector[i] = vector[i] + (N.NextDouble() * strategyParameters[i % strategyParameters.Length]);
}
} else {
// BackwardsCompatibility3.3
#region Backwards compatible region (remove with 3.4)
// when upgrading to 3.4 remove the whole condition and just put the if-branch in place (you should then also throw an ArgumentException when strategyParameters is null or has length 0)
for (int i = 0; i < vector.Length; i++) {
vector[i] = vector[i] + N.NextDouble();
}
#endregion
}
}
protected override List<List<double>> GenerateValues() {
List<List<double>> data = new List<List<double>>();
var nrand = new NormalDistributedRandom(random, 0, 1);
for (int c = 0; c < numberOfFeatures; c++) {
var datai = Enumerable.Range(0, TestPartitionEnd).Select(_ => nrand.NextDouble()).ToList();
data.Add(datai);
}
var y = GenerateRandomFunction(random, data);
var targetSigma = y.StandardDeviation();
var noisePrng = new NormalDistributedRandom(random, 0, targetSigma * Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
data.Add(y.Select(t => t + noisePrng.NextDouble()).ToList());
return data;
}
/// <summary>
/// Generates a new random real vector normally distributed around the given mean with the given <paramref name="length"/> and in the interval [min,max).
/// </summary>
/// <exception cref="ArgumentException">
/// Thrown when <paramref name="random"/> is null.<br />
/// Thrown when <paramref name="mean"/> is null or of length 0.<br />
/// Thrown when <paramref name="sigma"/> is null or of length 0.<br />
/// </exception>
/// <remarks>
/// If no bounds are given the bounds will be set to (double.MinValue;double.MaxValue).
///
/// If dimensions of the mean do not lie within the given bounds they're set to either to the min or max of the bounds depending on whether the given dimension
/// for the mean is smaller or larger than the bounds. If min and max for a certain dimension are almost the same the resulting value will be set to min.
///
/// However, please consider that such static bounds are not really meaningful to optimize.
///
/// The sigma vector can contain 0 values in which case the dimension will be exactly the same as the given mean.
/// </remarks>
/// <param name="random">The random number generator.</param>
/// <param name="means">The mean vector around which the resulting vector is sampled.</param>
/// <param name="sigmas">The vector of standard deviations, must have at least one row.</param>
/// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param>
/// <param name="maximumTries">The maximum number of tries to sample a value inside the bounds for each dimension. If a valid value cannot be obtained, the mean will be used.</param>
/// <returns>The newly created real vector.</returns>
public static RealVector Apply(IntValue lengthValue, IRandom random, RealVector means, DoubleArray sigmas, DoubleMatrix bounds, int maximumTries = 1000) {
if (lengthValue == null || lengthValue.Value == 0) throw new ArgumentException("Length is not defined or zero");
if (random == null) throw new ArgumentNullException("Random is not defined", "random");
if (means == null || means.Length == 0) throw new ArgumentNullException("Mean is not defined", "mean");
if (sigmas == null || sigmas.Length == 0) throw new ArgumentNullException("Sigma is not defined.", "sigma");
if (bounds == null || bounds.Rows == 0) bounds = new DoubleMatrix(new[,] { { double.MinValue, double.MaxValue } });
var length = lengthValue.Value;
var nd = new NormalDistributedRandom(random, 0, 1);
var result = new RealVector(length);
for (int i = 0; i < result.Length; i++) {
var min = bounds[i % bounds.Rows, 0];
var max = bounds[i % bounds.Rows, 1];
var mean = means[i % means.Length];
var sigma = sigmas[i % sigmas.Length];
if (min.IsAlmost(max) || mean < min) result[i] = min;
else if (mean > max) result[i] = max;
else {
int count = 0;
bool inRange;
do {
result[i] = mean + sigma * nd.NextDouble();
inRange = result[i] >= min && result[i] < max;
count++;
} while (count < maximumTries && !inRange);
if (count == maximumTries && !inRange)
result[i] = mean;
}
}
return result;
}
/// <summary>
/// Generates a new double random number.
/// </summary>
/// <returns>A double random number.</returns>
public double NextDouble()
{
return(NormalDistributedRandom.NextDouble(uniform, mu, sigma));
}
protected override List<List<double>> GenerateValues() {
List<List<double>> data = new List<List<double>>();
for (int i = 0; i < AllowedInputVariables.Count(); i++) {
data.Add(Enumerable.Range(0, TestPartitionEnd)
.Select(_ => xRandom.NextDouble())
.ToList());
}
var random = new MersenneTwister();
var selectedFeatures =
Enumerable.Range(0, AllowedInputVariables.Count())
.Where(_ => random.NextDouble() < selectionProbability)
.ToArray();
w = selectedFeatures.Select(_ => weightRandom.NextDouble()).ToArray();
var target = new List<double>();
for (int i = 0; i < data[0].Count; i++) {
var s = selectedFeatures
.Select(index => data[index][i])
.ToArray();
target.Add(ScalarProd(s, w));
}
var targetSigma = target.StandardDeviation();
var noisePrng = new NormalDistributedRandom(random, 0, targetSigma * Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
data.Add(target.Select(t => t + noisePrng.NextDouble()).ToList());
// set property listing the selected features as string[]
this.selectedFeatures = selectedFeatures.Select(i => AllowedInputVariables[i]).ToArray();
optimalRSquared = 1 - noiseRatio;
return data;
}
/// <summary>
/// Generates a new normally distributed random variable and assigns it to the specified variable.
/// </summary>
public override IOperation Apply() {
IRandom random = RandomParameter.ActualValue;
double mu = MuParameter.ActualValue.Value;
double sigma = SigmaParameter.ActualValue.Value;
NormalDistributedRandom normalRandom = new NormalDistributedRandom(random, mu, sigma);
ValueParameter.ActualValue = new DoubleValue(normalRandom.NextDouble());
return base.Apply();
}
public override IOperation Apply() {
var maxTries = MaxTriesParameter.Value.Value;
var truncateAtBounds = TruncateAtBoundsParameter.Value.Value;
var random = RandomParameter.ActualValue;
var lambda = PopulationSizeParameter.ActualValue.Value;
var xmean = MeanParameter.ActualValue;
var arx = RealVectorParameter.ActualValue;
var sp = StrategyParametersParameter.ActualValue;
var iterations = IterationsParameter.ActualValue.Value;
var initialIterations = sp.InitialIterations;
var bounds = BoundsParameter.ActualValue;
if (arx == null || arx.Length == 0) {
arx = new ItemArray<RealVector>(lambda);
for (int i = 0; i < lambda; i++) arx[i] = new RealVector(xmean.Length);
RealVectorParameter.ActualValue = arx;
}
var nd = new NormalDistributedRandom(random, 0, 1);
var length = arx[0].Length;
for (int i = 0; i < lambda; i++) {
int tries = 0;
bool inRange;
if (initialIterations > iterations) {
for (int k = 0; k < length; k++) {
do {
arx[i][k] = xmean[k] + sp.Sigma * sp.D[k] * nd.NextDouble();
inRange = bounds[k % bounds.Rows, 0] <= arx[i][k] && arx[i][k] <= bounds[k % bounds.Rows, 1];
if (!inRange) tries++;
} while (!inRange && tries < maxTries);
if (!inRange && truncateAtBounds) {
if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
}
}
} else {
var B = sp.B;
do {
tries++;
inRange = true;
var artmp = new double[length];
for (int k = 0; k < length; ++k) {
artmp[k] = sp.D[k] * nd.NextDouble();
}
for (int k = 0; k < length; k++) {
var sum = 0.0;
for (int j = 0; j < length; j++)
sum += B[k, j] * artmp[j];
arx[i][k] = xmean[k] + sp.Sigma * sum; // m + sig * Normal(0,C)
if (bounds[k % bounds.Rows, 0] > arx[i][k] || arx[i][k] > bounds[k % bounds.Rows, 1])
inRange = false;
}
} while (!inRange && tries < maxTries);
if (!inRange && truncateAtBounds) {
for (int k = 0; k < length; k++) {
if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
}
}
}
}
return base.Apply();
}
protected override List<List<double>> GenerateValues() {
// variable names are shuffled in the beginning (and sorted at the end)
variableNames = variableNames.Shuffle(random).ToArray();
// a third of all variables are independent vars
List<List<double>> lvl0 = new List<List<double>>();
int numLvl0 = (int)Math.Ceiling(numberOfFeatures * 0.33);
List<string> description = new List<string>(); // store information how the variable is actually produced
List<string[]> inputVarNames = new List<string[]>(); // store information to produce graphviz file
var nrand = new NormalDistributedRandom(random, 0, 1);
for (int c = 0; c < numLvl0; c++) {
var datai = Enumerable.Range(0, TestPartitionEnd).Select(_ => nrand.NextDouble()).ToList();
inputVarNames.Add(new string[] { });
description.Add("~ N(0, 1)");
lvl0.Add(datai);
}
// lvl1 contains variables which are functions of vars in lvl0 (+ noise)
List<List<double>> lvl1 = new List<List<double>>();
int numLvl1 = (int)Math.Ceiling(numberOfFeatures * 0.33);
for (int c = 0; c < numLvl1; c++) {
string[] selectedVarNames;
var x = GenerateRandomFunction(random, lvl0, out selectedVarNames);
var sigma = x.StandardDeviation();
var noisePrng = new NormalDistributedRandom(random, 0, sigma * Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
lvl1.Add(x.Select(t => t + noisePrng.NextDouble()).ToList());
inputVarNames.Add(selectedVarNames);
var desc = string.Format("f({0})", string.Join(",", selectedVarNames));
description.Add(string.Format(" ~ N({0}, {1:N3})", desc, noisePrng.Sigma));
}
// lvl2 contains variables which are functions of vars in lvl0 and lvl1 (+ noise)
List<List<double>> lvl2 = new List<List<double>>();
int numLvl2 = (int)Math.Ceiling(numberOfFeatures * 0.2);
for (int c = 0; c < numLvl2; c++) {
string[] selectedVarNames;
var x = GenerateRandomFunction(random, lvl0.Concat(lvl1).ToList(), out selectedVarNames);
var sigma = x.StandardDeviation();
var noisePrng = new NormalDistributedRandom(random, 0, sigma * Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
lvl2.Add(x.Select(t => t + noisePrng.NextDouble()).ToList());
inputVarNames.Add(selectedVarNames);
var desc = string.Format("f({0})", string.Join(",", selectedVarNames));
description.Add(string.Format(" ~ N({0}, {1:N3})", desc, noisePrng.Sigma));
}
// lvl3 contains variables which are functions of vars in lvl0, lvl1 and lvl2 (+ noise)
List<List<double>> lvl3 = new List<List<double>>();
int numLvl3 = numberOfFeatures - numLvl0 - numLvl1 - numLvl2;
for (int c = 0; c < numLvl3; c++) {
string[] selectedVarNames;
var x = GenerateRandomFunction(random, lvl0.Concat(lvl1).Concat(lvl2).ToList(), out selectedVarNames);
var sigma = x.StandardDeviation();
var noisePrng = new NormalDistributedRandom(random, 0, sigma * Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
lvl3.Add(x.Select(t => t + noisePrng.NextDouble()).ToList());
inputVarNames.Add(selectedVarNames);
var desc = string.Format("f({0})", string.Join(",", selectedVarNames));
description.Add(string.Format(" ~ N({0}, {1:N3})", desc, noisePrng.Sigma));
}
networkDefinition = string.Join(Environment.NewLine, variableNames.Zip(description, (n, d) => n + d));
// for graphviz
networkDefinition += Environment.NewLine + "digraph G {";
foreach (var t in variableNames.Zip(inputVarNames, Tuple.Create).OrderBy(t => t.Item1)) {
var name = t.Item1;
var selectedVarNames = t.Item2;
foreach (var selectedVarName in selectedVarNames) {
networkDefinition += Environment.NewLine + selectedVarName + " -> " + name;
}
}
networkDefinition += Environment.NewLine + "}";
// return a random permutation of all variables
var allVars = lvl0.Concat(lvl1).Concat(lvl2).Concat(lvl3).ToList();
var orderedVars = allVars.Zip(variableNames, Tuple.Create).OrderBy(t => t.Item2).Select(t => t.Item1).ToList();
variableNames = variableNames.OrderBy(n => n).ToArray();
return orderedVars;
}
/// <summary>
/// Initializes a new instance from an existing one (copy constructor).
/// </summary>
/// <param name="original">The original <see cref="NormalDistributedRandom"/> instance which is used to initialize the new instance.</param>
/// <param name="cloner">A <see cref="Cloner"/> which is used to track all already cloned objects in order to avoid cycles.</param>
private NormalDistributedRandom(NormalDistributedRandom original, Cloner cloner)
: base(original, cloner) {
uniform = cloner.Clone(original.uniform);
mu = original.mu;
sigma = original.sigma;
}
