private Vector <double> SampleSolution()
{
if (_B == null || _D == null)
{
_C = (_C + _C.Transpose()) / 2;
MathNet.Numerics.LinearAlgebra.Factorization.Evd <double> evd_C = _C.Evd();
Matrix <double> B = evd_C.EigenVectors;
Vector <double> D = Vector <double> .Build.Dense(evd_C.EigenValues.PointwiseSqrt().Select(tmp => tmp.Real).ToArray());
D += _epsilon;
_B = B;
_D = D;
Matrix <double> D2diagonal = Matrix <double> .Build.DenseDiagonal(D.Count, 1);
Vector <double> Dpow2 = D.PointwisePower(2);
for (int i = 0; i < D2diagonal.RowCount; i++)
{
D2diagonal[i, i] = Dpow2[i];
}
Matrix <double> BD2 = B * D2diagonal;
_C = BD2 * B.Transpose();
}
Vector <double> z = Vector <double> .Build.Dense(Dim);
for (int i = 0; i < z.Count; i++)
{
z[i] = Normal.Sample(_rng, 0, 1);
}
Matrix <double> Ddiagonal = Matrix <double> .Build.DenseDiagonal(_D.Count, 1);
for (int i = 0; i < Ddiagonal.RowCount; i++)
{
Ddiagonal[i, i] = _D[i];
}
Matrix <double> y = _B * Ddiagonal * z.ToColumnMatrix();
Vector <double> x = _mean + (_sigma * y.Column(0));
return(x);
}
/// <summary>
/// Gets solution CMA_ES.
/// </summary>
/// <returns>Solution</returns>
public Vector <double> SampleSolution()
{
if (_B == null || _D == null)
{
C = (C + C.Transpose()) / 2;
MathNet.Numerics.LinearAlgebra.Factorization.Evd <double> evd_C = C.Evd();
Matrix <double> newB = evd_C.EigenVectors;
Vector <double> newD = Vector <double> .Build.Dense(evd_C.EigenValues.PointwiseSqrt().Select(tmp => tmp.Real).ToArray());
newD += epsilon;
_B = newB;
_D = newD;
Matrix <double> D2diagonal = Matrix <double> .Build.DenseDiagonal(newD.Count, 1);
Vector <double> Dpow2 = newD.PointwisePower(2);
for (int i = 0; i < D2diagonal.RowCount; i++)
{
D2diagonal[i, i] = Dpow2[i];
}
Matrix <double> BD2 = newB * D2diagonal;
C = BD2 * newB.Transpose();
}
Vector <double> z = Vector <double> .Build.Dense(nDim);
for (int i = 0; i < z.Count; i++)
{
z[i] = MathNet.Numerics.Distributions.Normal.Sample(FastRandom.Instance, 0, 1);
}
Matrix <double> Ddiagonal = Matrix <double> .Build.DenseDiagonal(_D.Count, 1);
for (int i = 0; i < Ddiagonal.RowCount; i++)
{
Ddiagonal[i, i] = _D[i];
}
Matrix <double> y = _B * Ddiagonal * z.ToColumnMatrix();
Vector <double> x = _mean + (sigma * y.Column(0));
return(x);
}
/// <summary>
/// The covariance matrix and step size are recalculated based on the search vectors and their results.
/// </summary>
/// <param name="solutions">Tuple's list of search vectors and result values.</param>
public void Tell(List <Tuple <Vector <double>, double> > solutions)
{
if (solutions.Count != PopulationSize)
{
throw new ArgumentException("Must tell popsize-length solutions.");
}
Generation += 1;
Tuple <Vector <double>, double>[] sortedSolutions = solutions.OrderBy(x => x.Item2).ToArray();
// Sample new population of search_points, for k=1, ..., popsize
Matrix <double> B = Matrix <double> .Build.Dense(_B.RowCount, _B.ColumnCount);
Vector <double> D = Vector <double> .Build.Dense(_D.Count);
if (_B == null || _D == null)
{
_C = (_C + _C.Transpose()) / 2;
MathNet.Numerics.LinearAlgebra.Factorization.Evd <double> evd_C = _C.Evd();
B = evd_C.EigenVectors;
D = Vector <double> .Build.Dense(evd_C.EigenValues.PointwiseSqrt().Select(tmp => tmp.Real).ToArray());
}
else
{
_B.CopyTo(B);
_D.CopyTo(D);
}
_B = null;
_D = null;
Matrix <double> x_k = Matrix <double> .Build.DenseOfRowVectors(sortedSolutions.Select(x => x.Item1));
Matrix <double> y_k = Matrix <double> .Build.Dense(sortedSolutions.Length, Dim);
for (int i = 0; i < sortedSolutions.Length; i++)
{
y_k.SetRow(i, (x_k.Row(i) - _mean) / _sigma);
}
// Selection and recombination
Vector <double>[] kk = y_k.EnumerateRows().Take(_mu).ToArray();
Matrix <double> y_k_T = Matrix <double> .Build.Dense(Dim, kk.Length);
for (int i = 0; i < kk.Length; i++)
{
y_k_T.SetColumn(i, kk[i]);
}
Vector <double> subWeights = Vector <double> .Build.Dense(_weights.Take(_mu).ToArray());
Matrix <double> y_w_matrix = Matrix <double> .Build.Dense(y_k_T.RowCount, y_k_T.ColumnCount);
for (int i = 0; i < y_w_matrix.RowCount; i++)
{
y_w_matrix.SetRow(i, y_k_T.Row(i).PointwiseMultiply(subWeights));
}
Vector <double> y_w = y_w_matrix.RowSums();
_mean += _cm * _sigma * y_w;
Vector <double> D_bunno1_diag = 1 / D;
Matrix <double> D_bunno1_diagMatrix = Matrix <double> .Build.Dense(D_bunno1_diag.Count, D_bunno1_diag.Count);
for (int i = 0; i < D_bunno1_diag.Count; i++)
{
D_bunno1_diagMatrix[i, i] = D_bunno1_diag[i];
}
Matrix <double> C_2 = B * D_bunno1_diagMatrix * B;
_p_sigma = ((1 - _c_sigma) * _p_sigma) + (Math.Sqrt(_c_sigma * (2 - _c_sigma) * _mu_eff) * C_2 * y_w);
double norm_pSigma = _p_sigma.L2Norm();
_sigma *= Math.Exp(_c_sigma / _d_sigma * ((norm_pSigma / _chi_n) - 1));
double h_sigma_cond_left = norm_pSigma / Math.Sqrt(1 - Math.Pow(1 - _c_sigma, 2 * (Generation + 1)));
double h_sigma_cond_right = (1.4 + (2 / (double)(Dim + 1))) * _chi_n;
double h_sigma = h_sigma_cond_left < h_sigma_cond_right ? 1.0 : 0.0;
_pc = ((1 - _cc) * _pc) + (h_sigma * Math.Sqrt(_cc * (2 - _cc) * _mu_eff) * y_w);
Vector <double> w_io = Vector <double> .Build.Dense(_weights.Count, 1);
Vector <double> w_iee = (C_2 * y_k.Transpose()).ColumnNorms(2).PointwisePower(2);
for (int i = 0; i < _weights.Count; i++)
{
if (_weights[i] >= 0)
{
w_io[i] = _weights[i] * 1;
}
else
{
w_io[i] = _weights[i] * Dim / (w_iee[i] + _epsilon);
}
}
double delta_h_sigma = (1 - h_sigma) * _cc * (2 - _cc);
if (!(delta_h_sigma <= 1))
{
throw new Exception("invalid value of delta_h_sigma");
}
Matrix <double> rank_one = _pc.OuterProduct(_pc);
Matrix <double> rank_mu = Matrix <double> .Build.Dense(y_k.ColumnCount, y_k.ColumnCount, 0);
for (int i = 0; i < w_io.Count; i++)
{
rank_mu += w_io[i] * y_k.Row(i).OuterProduct(y_k.Row(i));
}
_C = ((1 + (_c1 * delta_h_sigma) - _c1 - (_cmu * _weights.Sum())) * _C) + (_c1 * rank_one) + (_cmu * rank_mu);
}
public static Transform DoPCA(DenseMatrix inputMat)
{
double[] Origin = new double[3];
double[] BasisX = new double[3];
double[] BasisY = new double[3];
double[] BasisZ = new double[3];
double Scale;
DenseMatrix dataMat = inputMat.SubMatrix(0, 3, 0, inputMat.ColumnCount) as DenseMatrix;
DenseMatrix meanMat = getMeanMat(dataMat);
Origin[0] = meanMat[0, 0];
Origin[1] = meanMat[1, 0];
Origin[2] = meanMat[2, 0];
dataMat = dataMat - meanMat;
DenseMatrix covar = dataMat * dataMat.Transpose() as DenseMatrix;
//bool EvSuccess = covar.ComputeEvJacobi(dblEigenValue, mtxEigenVector, eps);
MathNet.Numerics.LinearAlgebra.Factorization.Evd <double> evd = covar.Evd(Symmetricity.Symmetric);
Vector <Complex> eigenValues = evd.EigenValues;
DenseMatrix eigenVectors = evd.EigenVectors as DenseMatrix;
//sortedEigenValues = new double[3];
//if (!EvSuccess) return false;
int index = getMaxEigenValueIndex(eigenValues);
//sortedEigenValues[0] = eigenValues[index].Magnitude;
//eigenValues[index] = 0;
BasisX[0] = eigenVectors[0, index];
BasisX[1] = eigenVectors[1, index];
BasisX[2] = eigenVectors[2, index];
//index = getMaxEigenValueIndex(eigenValues);
//sortedEigenValues[1] = eigenValues[index].Magnitude;
//eigenValues[index] = 0;
//BasisY[0] = eigenVectors[0, index];
//BasisY[1] = eigenVectors[1, index];
//BasisY[2] = eigenVectors[2, index];
//index = getMaxEigenValueIndex(eigenValues);
//sortedEigenValues[2] = eigenValues[index].Magnitude;
//eigenValues[index] = 0;
//BasisZ[0] = eigenVectors[0, index];
//BasisZ[1] = eigenVectors[1, index];
//BasisZ[2] = eigenVectors[2, index];
double pmin, pmax;
pmin = BasisX[0] * dataMat[0, 0] + BasisX[1] * dataMat[1, 0] + BasisX[2] * dataMat[2, 0];
pmax = pmin;
for (int i = 1; i < inputMat.ColumnCount; i++)
{
double pdata = BasisX[0] * dataMat[0, i] + BasisX[1] * dataMat[1, i] + BasisX[2] * dataMat[2, i];
if (pdata > pmax)
{
pmax = pdata;
}
if (pdata < pmin)
{
pmin = pdata;
}
}
Scale = pmax - pmin;
//PCATrans = new Transform(BasisX, BasisY, BasisZ, Origin, Scale);
//PCATrans = new Transform(
DenseMatrix mat = DenseMatrix.CreateIdentity(4);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
mat[i, j] = eigenVectors[i, j] * Scale;
}
mat[i, 3] = Origin[i];
}
Transform PCATrans = new Transform(mat);
return(PCATrans);
}
