protected MOCMAEvolutionStrategy(MOCMAEvolutionStrategy original, Cloner cloner) : base(original, cloner)
{
random = cloner.Clone(original.random);
gauss = cloner.Clone(original.gauss);
solutions = original.solutions != null?original.solutions.Select(cloner.Clone).ToArray() : null;
stepSizeLearningRate = original.stepSizeLearningRate;
stepSizeDampeningFactor = original.stepSizeDampeningFactor;
targetSuccessProbability = original.targetSuccessProbability;
evolutionPathLearningRate = original.evolutionPathLearningRate;
covarianceMatrixLearningRate = original.covarianceMatrixLearningRate;
covarianceMatrixUnlearningRate = original.covarianceMatrixUnlearningRate;
successThreshold = original.successThreshold;
}
public override void ShakeLocalParameters(IRandom random, double shakingFactor)
{
base.ShakeLocalParameters(random, shakingFactor);
// 50% additive & 50% multiplicative
if (random.NextDouble() < 0.5)
{
double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorMu, Symbol.ManipulatorSigma);
Value = Value + x * shakingFactor;
}
else
{
double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeManipulatorSigma);
Value = Value * x;
}
}
/// <summary>
/// Performs an adaptive normally distributed all position manipulation on the given
/// <paramref name="vector"/> and rounding the results to the next feasible value.
/// </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 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>
public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray strategyParameters) {
if (strategyParameters == null || strategyParameters.Length == 0) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
var N = new NormalDistributedRandom(random, 0.0, 1.0);
if (strategyParameters != null) {
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() * strategyParameters[i % strategyParameters.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());
}
protected override void Initialize(CancellationToken cancellationToken)
{
if (SetSeedRandomly)
{
Seed = RandomSeedGenerator.GetSeed();
}
random.Reset(Seed);
gauss = new NormalDistributedRandom(random, 0, 1);
InitResults();
InitStrategy();
InitSolutions();
Analyze();
ResultsIterations = 1;
}
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);
}
private IEnumerable <double> SampleGaussianProcess(IRandom random, List <double>[] xs)
{
int nl = xs.Length;
int nRows = xs.First().Count;
double[,] K = new double[nRows, nRows];
// sample length-scales
var l = Enumerable.Range(0, nl)
.Select(_ => random.NextDouble() * 2 + 0.5)
.ToArray();
// calculate covariance matrix
for (int r = 0; r < nRows; r++)
{
double[] xi = xs.Select(x => x[r]).ToArray();
for (int c = 0; c <= r; c++)
{
double[] xj = xs.Select(x => x[c]).ToArray();
double dSqr = xi.Zip(xj, (xik, xjk) => (xik - xjk))
.Select(dk => dk * dk)
.Zip(l, (dk, lk) => dk / lk)
.Sum();
K[r, c] = Math.Exp(-dSqr);
}
}
// add a small diagonal matrix for numeric stability
for (int i = 0; i < nRows; i++)
{
K[i, i] += 1.0E-7;
}
// decompose
alglib.trfac.spdmatrixcholesky(ref K, nRows, false);
// sample u iid ~ N(0, 1)
var u = Enumerable.Range(0, nRows).Select(_ => NormalDistributedRandom.NextDouble(random, 0, 1)).ToArray();
// calc y = Lu
var y = new double[u.Length];
alglib.ablas.rmatrixmv(nRows, nRows, K, 0, 0, 0, u, 0, ref y, 0);
return(y);
}
public static void UpdateVelocity(IRandom random, RealVector velocity, RealVector position, RealVector personalBest, RealVector neighborBest, double inertia = 0.721, double personalBestAttraction = 1.193, double neighborBestAttraction = 1.193, double maxVelocity = double.MaxValue)
{
var gravity = new double[velocity.Length];
var direction = new RealVector(velocity.Length);
var radius = 0.0;
var nd = new NormalDistributedRandom(random, 0, 1);
for (int i = 0; i < velocity.Length; i++)
{
var g_id = (personalBestAttraction * personalBest[i]
+ neighborBestAttraction * neighborBest[i]
- position[i] * (neighborBestAttraction + personalBestAttraction)) / 3.0;
// center of the hyper-sphere
gravity[i] = g_id + position[i];
// a random direction vector uniform over the surface of hyper-sphere, see http://mathworld.wolfram.com/HyperspherePointPicking.html
direction[i] = nd.NextDouble();
radius += g_id * g_id;
}
// randomly choose a radius within the hyper-sphere
radius = random.NextDouble() * Math.Sqrt(radius);
// unitscale is used to rescale the random direction vector to unit length, resp. length of the radius
var unitscale = Math.Sqrt(direction.DotProduct(direction));
if (unitscale > 0)
{
for (var i = 0; i < velocity.Length; i++)
{
var sampledPos = gravity[i] + direction[i] * radius / unitscale;
velocity[i] = velocity[i] * inertia + sampledPos - position[i];
}
}
var speed = Math.Sqrt(velocity.DotProduct(velocity));
if (speed > maxVelocity)
{
for (var i = 0; i < velocity.Length; i++)
{
velocity[i] *= maxVelocity / speed;
}
}
}
protected override List <List <double> > GenerateValues()
{
List <List <double> > data = new List <List <double> >();
List <int> values = new List <int>()
{
-1, 1
};
var rand = new MersenneTwister((uint)Seed);
data.Add(GenerateUniformIntegerDistribution(rand, values, TestPartitionEnd));
values.Add(0);
for (int i = 0; i < AllowedInputVariables.Count() - 1; i++)
{
data.Add(GenerateUniformIntegerDistribution(rand, values, TestPartitionEnd));
}
double x1, x2, x3, x4, x5, x6, x7;
double f;
List <double> results = new List <double>();
double sigma = Math.Sqrt(2);
for (int i = 0; i < data[0].Count; i++)
{
x1 = data[0][i];
x2 = data[1][i];
x3 = data[2][i];
x4 = data[3][i];
x5 = data[4][i];
x6 = data[5][i];
x7 = data[6][i];
if (x1.Equals(1))
{
f = 3 + 3 * x2 + 2 * x3 + x4;
}
else
{
f = -3 + 3 * x5 + 2 * x6 + x7;
}
results.Add(f + NormalDistributedRandom.NextDouble(rand, 0, sigma));
}
data.Add(results);
return(data);
}
public override void ShakeLocalParameters(IRandom random, double shakingFactor)
{
base.ShakeLocalParameters(random, shakingFactor);
// 50% additive & 50% multiplicative
if (random.NextDouble() < 0)
{
double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
weight = weight + x * shakingFactor;
}
else
{
double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeWeightManipulatorSigma);
weight = weight * x;
}
#pragma warning disable 612, 618
variableName = Symbol.VariableNames.SelectRandom(random);
#pragma warning restore 612, 618
}
private static IEnumerable <double> EvaluateModelWithReplacedVariable(IRegressionModel model, string variable, ModifiableDataset dataset, IEnumerable <int> rows, ReplacementMethodEnum replacement = ReplacementMethodEnum.Median)
{
var originalValues = dataset.GetReadOnlyDoubleValues(variable).ToList();
double replacementValue;
List <double> replacementValues;
IRandom rand;
switch (replacement)
{
case ReplacementMethodEnum.Median:
replacementValue = rows.Select(r => originalValues[r]).Median();
replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
break;
case ReplacementMethodEnum.Average:
replacementValue = rows.Select(r => originalValues[r]).Average();
replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
break;
case ReplacementMethodEnum.Shuffle:
// new var has same empirical distribution but the relation to y is broken
rand = new FastRandom(31415);
replacementValues = rows.Select(r => originalValues[r]).Shuffle(rand).ToList();
break;
case ReplacementMethodEnum.Noise:
var avg = rows.Select(r => originalValues[r]).Average();
var stdDev = rows.Select(r => originalValues[r]).StandardDeviation();
rand = new FastRandom(31415);
replacementValues = rows.Select(_ => NormalDistributedRandom.NextDouble(rand, avg, stdDev)).ToList();
break;
default:
throw new ArgumentException(string.Format("ReplacementMethod {0} cannot be handled.", replacement));
}
dataset.ReplaceVariable(variable, replacementValues);
//mkommend: ToList is used on purpose to avoid lazy evaluation that could result in wrong estimates due to variable replacements
var estimates = model.GetEstimatedValues(dataset, rows).ToList();
dataset.ReplaceVariable(variable, originalValues);
return(estimates);
}
private IEnumerable <double> SampleLinearFunction(IRandom rand, List <double>[] xs, out double[] relevance)
{
int nl = xs.Length;
int nRows = xs.First().Count;
// sample standardized coefficients iid ~ N(0, 1)
var c = Enumerable.Range(0, nRows).Select(_ => NormalDistributedRandom.NextDouble(rand, 0, 1)).ToArray();
// calculate scaled coefficients (variables with large variance should have smaller coefficients)
var scaledC = Enumerable.Range(0, nl)
.Select(i => c[i] / xs[i].StandardDeviationPop())
.ToArray();
var y = EvaluteLinearModel(xs, scaledC);
relevance = CalculateRelevance(y, xs, scaledC);
return(y);
}
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);
}
protected override List <List <double> > GenerateValues()
{
var rand = new MersenneTwister((uint)Seed);
List <List <double> > data = new List <List <double> >();
var C_La = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.4, 0.8).ToList();
var a = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5.0, 10.0).ToList();
var C_Ld_e = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.4, 0.8).ToList();
var d_e = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5.0, 10.0).ToList();
var S_HT = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 1.5).ToList();
var S_ref = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5.0, 7.0).ToList();
var C_L = new List <double>();
var C_L_noise = new List <double>();
data.Add(C_La);
data.Add(a);
data.Add(C_Ld_e);
data.Add(d_e);
data.Add(S_HT);
data.Add(S_ref);
data.Add(C_L);
data.Add(C_L_noise);
double a0 = -2.0;
for (int i = 0; i < C_La.Count; i++)
{
double C_Li = C_La[i] * (a[i] - a0) + C_Ld_e[i] * d_e[i] * S_HT[i] / S_ref[i];
C_L.Add(C_Li);
}
var sigma_noise = 0.05 * C_L.StandardDeviationPop();
C_L_noise.AddRange(C_L.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
return(data);
}
/// <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> >();
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);
}
protected override List <List <double> > GenerateValues()
{
var rand = new MersenneTwister((uint)Seed);
List <List <double> > data = new List <List <double> >();
var V_inf = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 60.0, 65.0).ToList();
var th = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 30.0, 40.0).ToList();
var r = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.5, 0.8).ToList();
var R = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.2, 0.5).ToList();
var G = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5, 10).ToList();
var Psi = new List <double>();
var Psi_noise = new List <double>();
data.Add(V_inf);
data.Add(th);
data.Add(r);
data.Add(R);
data.Add(G);
data.Add(Psi);
data.Add(Psi_noise);
for (int i = 0; i < V_inf.Count; i++)
{
var th_rad = Math.PI * th[i] / 180.0;
double Psi_i = V_inf[i] * r[i] * Math.Sin(th_rad) * (1 - (R[i] * R[i]) / (r[i] * r[i])) +
(G[i] / (2 * Math.PI)) * Math.Log(r[i] / R[i]);
Psi.Add(Psi_i);
}
var sigma_noise = 0.05 * Psi.StandardDeviationPop();
Psi_noise.AddRange(Psi.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
return(data);
}
public override void ShakeLocalParameters(IRandom random, double shakingFactor)
{
base.ShakeLocalParameters(random, shakingFactor);
// 50% additive & 50% multiplicative (TODO: BUG in if statement below -> fix in HL 4.0!)
if (random.NextDouble() < 0)
{
double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
weight = weight + x * shakingFactor;
}
else
{
double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeWeightManipulatorSigma);
weight = weight * x;
}
if (Symbol.VariableChangeProbability >= 1.0)
{
// old behaviour for backwards compatibility
#region Backwards compatible code, remove with 3.4
#pragma warning disable 612, 618
variableName = Symbol.VariableNames.SelectRandom(random);
#pragma warning restore 612, 618
#endregion
}
else if (random.NextDouble() < Symbol.VariableChangeProbability)
{
var oldName = variableName;
variableName = Symbol.VariableNames.SampleRandom(random);
if (oldName != variableName)
{
// re-initialize weight if the variable is changed
weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
}
}
}
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());
}
/// <summary>
/// Fits a model to the data by optimizing the numeric constants.
/// Model is specified as infix expression containing variable names and numbers.
/// The starting point for the numeric constants is initialized randomly if a random number generator is specified (~N(0,1)). Otherwise the user specified constants are
/// used as a starting point.
/// </summary>-
/// <param name="problemData">Training and test data</param>
/// <param name="modelStructure">The function as infix expression</param>
/// <param name="maxIterations">Number of constant optimization iterations (using Levenberg-Marquardt algorithm)</param>
/// <param name="random">Optional random number generator for random initialization of numeric constants.</param>
/// <returns></returns>
public static ISymbolicRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData, string modelStructure, int maxIterations, bool applyLinearScaling, IRandom rand = null)
{
var parser = new InfixExpressionParser();
var tree = parser.Parse(modelStructure);
// parser handles double and string variables equally by creating a VariableTreeNode
// post-process to replace VariableTreeNodes by FactorVariableTreeNodes for all string variables
var factorSymbol = new FactorVariable();
factorSymbol.VariableNames =
problemData.AllowedInputVariables.Where(name => problemData.Dataset.VariableHasType <string>(name));
factorSymbol.AllVariableNames = factorSymbol.VariableNames;
factorSymbol.VariableValues =
factorSymbol.VariableNames.Select(name =>
new KeyValuePair <string, Dictionary <string, int> >(name,
problemData.Dataset.GetReadOnlyStringValues(name).Distinct()
.Select((n, i) => Tuple.Create(n, i))
.ToDictionary(tup => tup.Item1, tup => tup.Item2)));
foreach (var parent in tree.IterateNodesPrefix().ToArray())
{
for (int i = 0; i < parent.SubtreeCount; i++)
{
var varChild = parent.GetSubtree(i) as VariableTreeNode;
var factorVarChild = parent.GetSubtree(i) as FactorVariableTreeNode;
if (varChild != null && factorSymbol.VariableNames.Contains(varChild.VariableName))
{
parent.RemoveSubtree(i);
var factorTreeNode = (FactorVariableTreeNode)factorSymbol.CreateTreeNode();
factorTreeNode.VariableName = varChild.VariableName;
factorTreeNode.Weights =
factorTreeNode.Symbol.GetVariableValues(factorTreeNode.VariableName).Select(_ => 1.0).ToArray();
// weight = 1.0 for each value
parent.InsertSubtree(i, factorTreeNode);
}
else if (factorVarChild != null && factorSymbol.VariableNames.Contains(factorVarChild.VariableName))
{
if (factorSymbol.GetVariableValues(factorVarChild.VariableName).Count() != factorVarChild.Weights.Length)
{
throw new ArgumentException(
string.Format("Factor variable {0} needs exactly {1} weights",
factorVarChild.VariableName,
factorSymbol.GetVariableValues(factorVarChild.VariableName).Count()));
}
parent.RemoveSubtree(i);
var factorTreeNode = (FactorVariableTreeNode)factorSymbol.CreateTreeNode();
factorTreeNode.VariableName = factorVarChild.VariableName;
factorTreeNode.Weights = factorVarChild.Weights;
parent.InsertSubtree(i, factorTreeNode);
}
}
}
if (!SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree))
{
throw new ArgumentException("The optimizer does not support the specified model structure.");
}
// initialize constants randomly
if (rand != null)
{
foreach (var node in tree.IterateNodesPrefix().OfType <ConstantTreeNode>())
{
double f = Math.Exp(NormalDistributedRandom.NextDouble(rand, 0, 1));
double s = rand.NextDouble() < 0.5 ? -1 : 1;
node.Value = s * node.Value * f;
}
}
var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, problemData.TrainingIndices,
applyLinearScaling: applyLinearScaling, maxIterations: maxIterations,
updateVariableWeights: false, updateConstantsInTree: true);
var model = new SymbolicRegressionModel(problemData.TargetVariable, tree, (ISymbolicDataAnalysisExpressionTreeInterpreter)interpreter.Clone());
if (applyLinearScaling)
{
model.Scale(problemData);
}
SymbolicRegressionSolution solution = new SymbolicRegressionSolution(model, (IRegressionProblemData)problemData.Clone());
solution.Model.Name = "Regression Model";
solution.Name = "Regression Solution";
return(solution);
}
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
List <double[]> relevances = new List <double[]>(); // stores variable relevance information (same order as given in inputVarNames)
var nrand = new NormalDistributedRandom(random, 0, 1);
for (int c = 0; c < numLvl0; c++)
{
inputVarNames.Add(new string[] { });
relevances.Add(new double[] { });
description.Add(" ~ N(0, 1 + noiseLvl)");
// use same generation procedure for all variables
var x = Enumerable.Range(0, TestPartitionEnd).Select(_ => nrand.NextDouble()).ToList();
var sigma = x.StandardDeviationPop();
var mean = x.Average();
for (int i = 0; i < x.Count; i++)
{
x[i] = (x[i] - mean) / sigma;
}
var noisePrng = new NormalDistributedRandom(random, 0, Math.Sqrt(noiseRatio / (1.0 - noiseRatio)));
lvl0.Add(x.Select(t => t + noisePrng.NextDouble()).ToList());
}
// lvl1 contains variables which are functions of vars in lvl0 (+ noise)
int numLvl1 = (int)Math.Ceiling(numberOfFeatures * 0.33);
List <List <double> > lvl1 = CreateVariables(lvl0, numLvl1, inputVarNames, description, relevances);
// lvl2 contains variables which are functions of vars in lvl0 and lvl1 (+ noise)
int numLvl2 = (int)Math.Ceiling(numberOfFeatures * 0.2);
List <List <double> > lvl2 = CreateVariables(lvl0.Concat(lvl1).ToList(), numLvl2, inputVarNames, description, relevances);
// lvl3 contains variables which are functions of vars in lvl0, lvl1 and lvl2 (+ noise)
int numLvl3 = numberOfFeatures - numLvl0 - numLvl1 - numLvl2;
List <List <double> > lvl3 = CreateVariables(lvl0.Concat(lvl1).Concat(lvl2).ToList(), numLvl3, inputVarNames, description, relevances);
this.variableRelevances.Clear();
for (int i = 0; i < variableNames.Length; i++)
{
var targetVarName = variableNames[i];
var targetRelevantInputs =
inputVarNames[i].Zip(relevances[i], (inputVar, rel) => new KeyValuePair <string, double>(inputVar, rel))
.ToArray();
variableRelevances.Add(targetVarName, targetRelevantInputs);
}
networkDefinition = string.Join(Environment.NewLine, variableNames.Zip(description, (n, d) => n + d).OrderBy(x => x));
// for graphviz
networkDefinition += Environment.NewLine + "digraph G {";
for (int i = 0; i < variableNames.Length; i++)
{
var name = variableNames[i];
var selectedVarNames = inputVarNames[i];
var selectedRelevances = relevances[i];
for (int j = 0; j < selectedVarNames.Length; j++)
{
var selectedVarName = selectedVarNames[j];
var selectedRelevance = selectedRelevances[j];
networkDefinition += Environment.NewLine + selectedVarName + " -> " + name +
string.Format(CultureInfo.InvariantCulture, " [label={0:N3}]", selectedRelevance);
}
}
networkDefinition += Environment.NewLine + "}";
// return a random permutation of all variables (to mix lvl0, lvl1, ... 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);
}
protected override List <List <double> > GenerateValues()
{
var rand = new MersenneTwister((uint)Seed);
List <List <double> > data = new List <List <double> >();
var x1 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.4, 0.8).ToList();
var x2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3.0, 4.0).ToList();
var x3 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 20.0, 30.0).ToList();
var x4 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2.0, 5.0).ToList();
var x13 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2.0, 5.0).ToList();
var x16 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2.0, 5.0).ToList();
// in the reference paper \Delta alpha_w/c is replaced by two variables x5*x6.
var x5 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 20).ToList(); // range for X5 is not specified in the paper, we use [0°..20°] for ∆αW/c
var x6 = Enumerable.Repeat(1.0, x5.Count).ToList(); // range for X6 is not specified in the paper. In the maximum lift formular there is only a single variable ∆αW/c in place of x5*x6.
var x7 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.5, 1.5).ToList();
var x10 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0.5, 1.5).ToList();
var x8 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 1.5).ToList();
var x11 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 1.5).ToList();
var x9 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 2.0).ToList();
var x12 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 2.0).ToList();
var x14 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 1.5).ToList();
var x17 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1.0, 1.5).ToList();
var x15 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5.0, 7.0).ToList();
var x18 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 10.0, 20.0).ToList();
List <double> fx = new List <double>();
List <double> fx_noise = new List <double>();
data.Add(x1);
data.Add(x2);
data.Add(x3);
data.Add(x4);
data.Add(x5);
data.Add(x6);
data.Add(x7);
data.Add(x8);
data.Add(x9);
data.Add(x10);
data.Add(x11);
data.Add(x12);
data.Add(x13);
data.Add(x14);
data.Add(x15);
data.Add(x16);
data.Add(x17);
data.Add(x18);
data.Add(fx);
data.Add(fx_noise);
for (int i = 0; i < x1.Count; i++)
{
double fxi = x1[i];
fxi = fxi - 0.25 * x4[i] * x5[i] * x6[i] * (4 + 0.1 * (x2[i] / x3[i]) - (x2[i] / x3[i]) * (x2[i] / x3[i]));
fxi = fxi + x13[i] * (x14[i] / x15[i]) * x18[i] * x7[i];
fxi = fxi - x13[i] * (x14[i] / x15[i]) * x8[i];
fxi = fxi + x13[i] * (x14[i] / x15[i]) * x9[i];
fxi = fxi + x16[i] * (x17[i] / x15[i]) * x18[i] * x10[i];
fxi = fxi - x16[i] * (x17[i] / x15[i]) * x11[i];
fxi = fxi + x16[i] * (x17[i] / x15[i]) * x12[i];
fx.Add(fxi);
}
var sigma_noise = 0.05 * fx.StandardDeviationPop();
fx_noise.AddRange(fx.Select(fxi => fxi + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
return(data);
}
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);
}
public TSNEState(IReadOnlyList <T> data, IDistance <T> distance, IRandom random, int newDimensions, double perplexity,
double theta, int stopLyingIter, int momSwitchIter, double momentum, double finalMomentum, double eta, bool randomInit)
{
this.distance = distance;
this.random = random;
this.newDimensions = newDimensions;
this.perplexity = perplexity;
this.theta = theta;
this.stopLyingIter = stopLyingIter;
this.momSwitchIter = momSwitchIter;
currentMomentum = momentum;
this.finalMomentum = finalMomentum;
this.eta = eta;
// initialize
noDatapoints = data.Count;
if (noDatapoints - 1 < 3 * perplexity)
{
throw new ArgumentException("Perplexity too large for the number of data points!");
}
exact = Math.Abs(theta) < double.Epsilon;
newData = new double[noDatapoints, newDimensions];
dY = new double[noDatapoints, newDimensions];
uY = new double[noDatapoints, newDimensions];
gains = new double[noDatapoints, newDimensions];
for (var i = 0; i < noDatapoints; i++)
{
for (var j = 0; j < newDimensions; j++)
{
gains[i, j] = 1.0;
}
}
p = null;
rowP = null;
colP = null;
valP = null;
//Calculate Similarities
if (exact)
{
p = CalculateExactSimilarites(data, distance, perplexity);
}
else
{
CalculateApproximateSimilarities(data, distance, perplexity, out rowP, out colP, out valP);
}
// Lie about the P-values (factor is 4 in the MATLAB implementation)
if (exact)
{
for (var i = 0; i < noDatapoints; i++)
{
for (var j = 0; j < noDatapoints; j++)
{
p[i, j] *= 12.0;
}
}
}
else
{
for (var i = 0; i < rowP[noDatapoints]; i++)
{
valP[i] *= 12.0;
}
}
// Initialize solution (randomly)
var rand = new NormalDistributedRandom(random, 0, 1);
for (var i = 0; i < noDatapoints; i++)
{
for (var j = 0; j < newDimensions; j++)
{
newData[i, j] = rand.NextDouble() * .0001;
}
}
if (!(data[0] is IReadOnlyList <double>) || randomInit)
{
return;
}
for (var i = 0; i < noDatapoints; i++)
{
for (var j = 0; j < newDimensions; j++)
{
var row = (IReadOnlyList <double>)data[i];
newData[i, j] = row[j % row.Count];
}
}
}
