public static double Distance(List <MDHParameters> dht, double[] target, double[] angles)
{
var currentPose = GetPositionVector(ForwardKinematics(dht, angles.ToList()));
var result = Norm.Euclidean(target.Subtract(currentPose));
return(result);
}
private void iterate(double[][] seeds, ConcurrentStack <double[]> maxcandidates, int index)
{
double[] point = seeds[index];
double[] mean = new double[point.Length];
double[] delta = new double[point.Length];
// we will keep moving it in the
// direction of the density modes
int iterations = 0;
// until convergence or max iterations reached
while (iterations < MaxIterations)
{
iterations++;
// compute the shifted mean
computeMeanShift(point, mean);
// extract the mean shift vector
for (int j = 0; j < mean.Length; j++)
{
delta[j] = point[j] - mean[j];
}
// update the point towards a mode
for (int j = 0; j < mean.Length; j++)
{
point[j] = mean[j];
}
// Check if we are already near any maximum point
if (cut && nearest(point, maxcandidates) != null)
{
break;
}
// check for convergence: magnitude of the mean shift
// vector converges to zero (Comaniciu 2002, page 606)
if (Norm.Euclidean(delta) < Tolerance * Bandwidth)
{
break;
}
}
if (cut)
{
double[] match = nearest(point, maxcandidates);
if (match != null)
{
seeds[index] = match;
}
else
{
maxcandidates.Push(point);
}
}
}
public void EuclideanTest()
{
double[,] a =
{
{ 15.4457, 0.4187, 15.6093 },
{ 0.0000, 2.5708, 0.6534 }
};
double[] expected =
{
21.9634, 2.6525
};
double[] actual = Norm.Euclidean(a, 1);
Assert.IsTrue(expected.IsEqual(actual, 0.001));
double[] expected2 =
{
15.4457, 2.6047, 15.6229
};
double[] actual2 = Norm.Euclidean(a, 0);
Assert.IsTrue(expected2.IsEqual(actual2, 0.001));
double actual3 = Norm.Euclidean(a.GetRow(0));
Assert.AreEqual(21.9634, actual3, 0.001);
}
public void EuclideanTest1()
{
float[,] a =
{
{ 15.4457f, 0.4187f, 15.6093f },
{ 0.0000f, 2.5708f, 0.6534f }
};
float[] expected =
{
21.9634f, 2.6525f
};
float[] actual = Norm.Euclidean(a, 1);
Assert.IsTrue(expected.IsEqual(actual, 0.001f));
float[] expected2 =
{
15.4457f, 2.6047f, 15.6229f
};
float[] actual2 = Norm.Euclidean(a, 0);
Assert.IsTrue(expected2.IsEqual(actual2, 0.001f));
float actual3 = Norm.Euclidean(a.GetRow(0));
Assert.AreEqual(21.9634f, actual3, 0.001);
}
private double[][] householder(double[] a)
{
double[] v = a.Divide((a[0] + Special.Sign(Norm.Euclidean(a), a[0])));
v[0] = 1;
var H = Jagged.Identity(a.Length);
var vr = Jagged.RowVector(v);
var vc = Jagged.ColumnVector(v);
var t = vc.Dot(vr);
H.Subtract((2 / v.Dot(v)).Multiply(t), result: H);
return(H);
}
double lmerr()
{
double err = 0;
for (int i = 0; i < patternCounter; i++)
{
var sample = (input.GetColumn(i));
var target = output.GetColumn(i);
err += Math.Sqrt(Norm.Euclidean((evallm(sample).Subtract(target))));
}
return(err);
}
// return jacobi and error in every pattern
public Tuple <double[, ], double[]> jacobi()
{
double[,] j = Matrix.Create(patternCounter, weightNum, 0d);
double [] err = Vector.Create(patternCounter, 0d);
for (int i = 0; i < patternCounter; i++)
{
var sample = (input.GetColumn(i));
var target = output.GetColumn(i);
var gr = gradient(target, sample);
err[i] = Math.Sqrt(Norm.Euclidean(lastLayer().fneo().Subtract(target)));
j.SetRow(i, gr);
}
return(new Tuple <double[, ], double[]>(j, err));
}
/// <summary>
/// Initializes a new instance of the <see cref="GramSchmidtOrthogonalization"/> class.
/// </summary>
///
/// <param name="value">The matrix <c>A</c> to be decomposed.</param>
/// <param name="modified">True to use modified Gram-Schmidt; false
/// otherwise. Default is true (and is the recommended setup).</param>
///
public GramSchmidtOrthogonalization(double[,] value, bool modified)
{
if (value.GetLength(0) != value.GetLength(1))
{
throw new DimensionMismatchException("value", "Matrix must be square.");
}
int size = value.GetLength(0);
q = new double[size, size];
r = new double[size, size];
if (modified)
{
for (int j = 0; j < size; j++)
{
double[] v = value.GetColumn(j);
for (int i = 0; i < j; i++)
{
r[i, j] = q.GetColumn(i).Dot(v);
var t = r[i, j].Multiply(q.GetColumn(i));
v.Subtract(t, result: v);
}
r[j, j] = Norm.Euclidean(v);
q.SetColumn(j, v.Divide(r[j, j]));
}
}
else
{
for (int j = 0; j < size; j++)
{
double[] v = value.GetColumn(j);
double[] a = value.GetColumn(j);
for (int i = 0; i < j; i++)
{
r[i, j] = q.GetColumn(j).Dot(a);
v = v.Subtract(r[i, j].Multiply(q.GetColumn(i)));
}
r[j, j] = Norm.Euclidean(v);
q.SetColumn(j, v.Divide(r[j, j]));
}
}
}
public double Similarity(Dictionary <string, double> mainDict, Dictionary <string, double> dct2)
{
var norm1 = Norm.Euclidean(mainDict.Values.ToArray());
var norm2 = Norm.Euclidean(dct2.Values.ToArray());
var dot = 0.0;
foreach (var label in mainDict)
{
if (dct2.ContainsKey(label.Key))
{
dot += mainDict[label.Key] * dct2[label.Key];
}
}
return(dot / (norm1 * norm2));
}
protected bool Equals(KLRotation other)
{
var innerProduct = Math.Abs(Math.Abs(Matrix.InnerProduct(RotationAxis, other.RotationAxis)) - 1);
if (innerProduct < 0.01)
{
if (RotationPoint != null && other.RotationPoint != null)
{
var pointDifferent = new double[]
{
RotationPoint[0] - other.RotationPoint[0], RotationPoint[1] - other.RotationPoint[1],
RotationPoint[2] - other.RotationPoint[2]
};
var norm = Norm.Euclidean(pointDifferent);
if (norm != 0.0)
{
pointDifferent = pointDifferent.Divide(norm);
}
else
{
return(true);
}
var innerProduct2 = Math.Abs(Math.Abs(Matrix.InnerProduct(RotationAxis, pointDifferent)) - 1);
//if (FolderUtilities.FolderUtilities.KLIsVectorNull(pointDifferent, 0.01))
//{
// return true;
//}
//else
if (innerProduct2 < 0.01)
{
return(true);
}
}
else if (RotationPoint == null || other.RotationPoint == null)
{
return(true);
}
}
return(false);
}
public double[] gradient(double[] target, double[] current)
{
double[] gr = Vector.Create(weightNum, 0d);
int pr = weightNum - 1;
var res = eval(current);
var lastdelta = Elementwise.Multiply(target.Subtract(res), lastLayer().gneo());
var err = 2 * Math.Sqrt(Norm.Euclidean(target.Subtract(res)));
double [,] wd = lastdelta.Outer(layers[layers.Count - 2].fneo()).Divide(err);
for (int i = wd.GetLength(0) - 1; i >= 0; i--)
{
for (int j = wd.GetLength(1) - 1; j >= 0; j--)
{
gr[pr--] = wd[i, j];
}
}
for (int j = layers.Count - 2; j > 0; j--)
{
var delta = Elementwise.Multiply(layers[j + 1].weights.Transpose().Dot(lastdelta), layers[j].gneo());
wd = lastdelta.Outer(layers[j - 1].fneo()).Divide(err);
for (int i = wd.GetLength(0) - 1; i >= 0; i--)
{
for (int jj = wd.GetLength(1) - 1; jj >= 0; jj--)
{
gr[pr--] = wd[i, jj];
}
}
lastdelta = delta;
}
var delta2 = Elementwise.Multiply(layers[1].weights.Transpose().Dot(lastdelta), layers[0].gneo());
wd = delta2.Outer(current).Divide(err);
for (int i = wd.GetLength(0) - 1; i >= 0; i--)
{
for (int j = wd.GetLength(1) - 1; j >= 0; j--)
{
gr[pr--] = wd[i, j];
}
}
return(gr);
}
public IActionResult TestAI()
{
var a = GetCategoriesFromDescription("Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice.");
var b = GetCategoriesFromDescription("Android is a mobile operating system developed by Google, based on the Linux kernel and designed primarily for touchscreen mobile devices such as smartphones and tablets.");
var c = GetCategoriesFromDescription("Google Cloud Platform, offered by Google, is a suite of cloud computing services that runs on the same infrastructure that Google uses internally for its end-user products, such as Google Search and YouTube. Alongside a set of management tools, it provides a series of modular cloud services including computing, data storage, data analytics and machine learning.");
var d = GetCategoriesFromDescription("Google is an American multinational technology company that specializes in Internet-related services and products. These include online advertising technologies, search, cloud computing, software, and hardware.");
var norm1 = Norm.Euclidean(a.Values.ToArray());
var norm2 = Norm.Euclidean(d.Values.ToArray());
var dot = 0.0;
foreach (var label in a)
{
if (d.ContainsKey(label.Key))
{
dot += a[label.Key] * d[label.Key];
}
}
//return Ok(d);
return(Ok(dot / (norm1 * norm2)));
}
/// <summary>
/// Constructs a Von-Mises Fisher distribution with unit mean.
/// </summary>
///
/// <param name="mean">The mean direction vector (with unit length).</param>
/// <param name="concentration">The concentration value κ (kappa).</param>
///
public VonMisesFisherDistribution(double[] mean, double concentration)
: base(mean.Length)
{
if (concentration < 0)
{
throw new ArgumentOutOfRangeException("concentration", "Concentration parameter kappa must be non-negative.");
}
if (!Norm.Euclidean(mean).IsRelativelyEqual(1, 1e-10))
{
throw new ArgumentOutOfRangeException("mean", "The mean vector must have unit length.");
}
this.mean = mean;
this.kappa = concentration;
int p = Dimension;
double num = Math.Pow(concentration, p / 2 - 1);
double den = Math.Pow(2 * Math.PI, p / 2) * Bessel.I(p / 2 - 1, concentration);
this.constant = num / den;
}
/// <summary>
/// Implements the actual optimization algorithm. This
/// method should try to minimize the objective function.
/// </summary>
///
protected override bool Optimize()
{
// This code has been adapted from the original
// FORTRAN function CGFAM by Jorge Nocedal, 1992.
int irest = 1;
int n = NumberOfVariables;
double[] x = Solution;
double f = Function(x);
g = Gradient(x);
int method = (int)Method;
iterations = 0;
evaluations = 1;
bool bnew = true;
int nrst = 0;
int im = 0; // Number of times betapr was negative for method 2 or 3
searches = 0; // Number of line search iterations after Wolfe conditions were satisfied.
double dg0 = 0;
for (int i = 0; i < g.Length; ++i)
{
d[i] = -g[i];
}
double gnorm = Norm.Euclidean(g);
double xnorm = Math.Max(1.0, Norm.Euclidean(x));
double stp1 = 1.0 / gnorm;
double f_old = f;
bool finish = false;
// Make initial progress report with initialization parameters
if (Progress != null)
{
Progress(this, new OptimizationProgressEventArgs
(iterations, evaluations, g, gnorm, Solution, xnorm, f, stp1, finish));
}
// Main iteration
while (!finish)
{
iterations++;
nrst++;
// Call the line search routine of Mor'e and Thuente
// (modified for Nocedal's CG method)
// -------------------------------------------------
//
// J.J. Mor'e and D. Thuente, "Linesearch Algorithms with Guaranteed
// Sufficient Decrease". ACM Transactions on Mathematical
// Software 20 (1994), pp 286-307.
//
int nfev = 0;
int info = 0;
double dgout = 0;
// Save original gradient
for (int i = 0; i < g.Length; i++)
{
gold[i] = g[i];
}
double dg = d.Dot(g);
double dgold = dg;
double stp = 1.0;
// Shanno-Phua's formula for trial step
if (!bnew)
{
stp = dg0 / dg;
}
if (iterations == 1)
{
stp = stp1;
}
int ides = 0;
bnew = false;
L72:
// Call to the line search subroutine
Status = cvsmod(ref f, d, ref stp, ref info, ref nfev, w, ref dg, ref dgout);
if (Status != ConjugateGradientCode.Success)
{
return(false);
}
// Test if descent direction is obtained for methods 2 and 3
double gg = Matrix.Dot(g, g);
double gg0 = Matrix.Dot(g, gold);
double betapr = (gg - gg0) / (gnorm * gnorm);
// When nrst > n and irest == 1 then restart.
if (irest == 1 && nrst > n)
{
nrst = 0;
bnew = true;
}
else
{
if (method != 1)
{
double dg1 = -gg + betapr * dgout;
if (dg1 >= 0.0)
{
ides++;
if (ides > 5)
{
Status = ConjugateGradientCode.DescentNotObtained;
return(false);
}
goto L72; // retry
}
}
}
evaluations += nfev;
searches += ides;
// Determine correct beta value for method chosen
double betafr = gg / (gnorm * gnorm);
double beta = 0;
if (nrst == 0)
{
beta = 0.0;
}
else
{
if (method == 1)
{
beta = betafr;
}
else if (method == 2)
{
beta = betapr;
}
else if (method == 3)
{
beta = Math.Max(0.0, betapr);
}
if ((method == 2 || method == 3) && betapr < 0.0)
{
im++;
}
}
// Compute the new direction
for (int i = 0; i < g.Length; i++)
{
d[i] = -g[i] + beta * d[i];
}
dg0 = dgold * stp;
// Check for termination
gnorm = Norm.Euclidean(g);
xnorm = Math.Max(1.0, Norm.Euclidean(x));
// Convergence test
if (gnorm / xnorm <= epsilon)
{
finish = true;
}
// Stopping criteria by function delta
if (tolerance > 0 && iterations > 1)
{
double delta = (f_old - f) / f;
f_old = f;
if (delta < tolerance)
{
finish = true;
}
}
// Stopping criteria by max iterations
if (maxIterations > 0)
{
if (iterations > maxIterations)
{
finish = true;
}
}
if (Progress != null)
{
Progress(this, new OptimizationProgressEventArgs(iterations,
evaluations, g, gnorm, Solution, xnorm, f, stp, finish));
}
}
return(Status == ConjugateGradientCode.Success);
}
/// <summary>
/// Deflation iterative algorithm.
/// </summary>
///
/// <returns>
/// Returns a matrix in which each row contains
/// the mixing coefficients for each component.
/// </returns>
///
private double[][] deflation(double[][] X, int components, double[][] init)
{
// References:
// - Hyvärinen, A (1999). Fast and Robust Fixed-Point
// Algorithms for Independent Component Analysis.
// There are two ways to apply the fixed-unit algorithm to compute the whole
// ICA iteration. The more simpler is to perform a deflation as in the Gram-
// Schmidt orthogonalization process [Hyvärinen]. In this scheme, independent
// components are estimated one-by-one. See referenced paper for details.
int n = X.Rows();
int m = X.Columns();
// Algorithm initialization
var W = Jagged.Zeros(components, m);
var wx = new double[n];
var gwx = new double[n];
var dgwx = new double[n];
// For each component to be computed,
for (int i = 0; i < components; i++)
{
// Will compute each of the basis vectors
// individually and sequentially, re-using
// previous computations to form basis W.
//
// Initialization
int iterations = 0;
bool stop = false;
//double lastChange = 1;
double[] w = init.GetRow(i);
double[] w0 = init.GetRow(i);
do // until convergence
{
// Start with deflation
for (int u = 0; u < i; u++)
{
double proj = 0;
for (int j = 0; j < w0.Length; j++)
{
proj += w0[j] * W[u][j];
}
for (int j = 0; j < w0.Length; j++)
{
w[j] = w0[j] - proj * W[u][j];
}
}
// Normalize
w = w.Divide(Norm.Euclidean(w));
// Gets the maximum parameter absolute change
double delta = getMaximumAbsoluteChange(w, w0);
// Check for convergence
if (!(delta > tolerance && iterations < maxIterations) || Token.IsCancellationRequested)
{
stop = true;
}
else
{
// Advance to the next iteration
w0 = w; w = new double[m];
//lastChange = delta;
iterations++;
// Compute wx = w*x
for (int j = 0; j < n; j++)
{
double s = 0;
for (int k = 0; k < w0.Length; k++)
{
s += w0[k] * X[j][k];
}
wx[j] = s;
}
// Compute g(w*x) and g'(w*x)
contrast.Evaluate(wx, gwx, dgwx);
// Compute E{ x*g(w*x) }
double[] means = new double[m];
for (int j = 0; j < means.Length; j++)
{
for (int k = 0; k < gwx.Length; k++)
{
means[j] += X[k][j] * gwx[k];
}
means[j] /= n;
}
// Compute E{ g'(w*x) }
double mean = Measures.Mean(dgwx);
// Compute next update for w according
// to Hyvärinen paper's equation (20).
// w+ = E{ xg(w*x)} - E{ g'(w*x)}*w
for (int j = 0; j < means.Length; j++)
{
w[j] = means[j] - mean * w0[j];
}
// The normalization to w* will be performed
// in the beginning of the next iteration.
}
} while (!stop);
// Store the just computed component
// in the resulting component matrix.
W.SetRow(i, w);
}
// Return the component basis matrix
return(W); // vectors stored as rows.
}
/// <summary>
/// Computes PLS parameters using SIMPLS algorithm.
/// </summary>
private void simpls(double[,] X0, double[,] Y0, int factors)
{
// Reference: Sijmen de Jong
// "SIMPLS: an alternative approach to partial least squares regression"
// Initialize and prepare the data
int rows = sourceX.GetLength(0);
int xcols = sourceX.GetLength(1);
int ycols = sourceY.GetLength(1);
// Initialize storage variables
double[,] P = new double[xcols, factors];
double[,] Q = new double[ycols, factors];
double[,] T = new double[rows, factors];
double[,] U = new double[rows, factors];
double[,] R = new double[xcols, factors];
double[] varX = new double[factors];
double[] varY = new double[factors];
// Orthogonal basis
double[,] V = new double[xcols, factors];
// Create covariance matrix X0'Y0
double[,] covariance = new double[xcols, ycols];
for (int i = 0; i < xcols; i++)
{
for (int j = 0; j < ycols; j++)
{
for (int k = 0; k < rows; k++)
{
covariance[i, j] += X0[k, i] * Y0[k, j];
}
}
}
#region SIMPLS
for (int iteration = 0; iteration < factors; iteration++)
{
// Perform SVD on the covariance matrix
SingularValueDecomposition svd = new SingularValueDecomposition(covariance);
double[] r = svd.LeftSingularVectors.GetColumn(0);
double[] c = svd.RightSingularVectors.GetColumn(0);
double s = svd.Diagonal[0];
// t = X0*r;
double[] t = new double[rows];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < xcols; j++)
{
t[i] += X0[i, j] * r[j];
}
}
// Normalize t
double norm_t = Norm.Euclidean(t);
for (int i = 0; i < t.Length; i++)
{
t[i] /= norm_t;
}
// p = X0'*t;
double[] p = new double[xcols];
for (int i = 0; i < xcols; i++)
{
for (int j = 0; j < rows; j++)
{
p[i] += X0[j, i] * t[j];
}
}
// q = s*c/norm(t);
double[] q = new double[ycols];
for (int j = 0; j < ycols; j++)
{
q[j] = s * c[j] / norm_t;
}
// u = Y0*q;
double[] u = new double[rows];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < ycols; j++)
{
u[i] += Y0[i, j] * q[j];
}
}
// Normalize r using norm(t)
for (int i = 0; i < r.Length; i++)
{
r[i] /= norm_t;
}
// Update the orthonormal basis V
double[] v = (double[])p.Clone();
for (int i = 0; i < 2; i++)
{
// Modified Gram-Schmidt to deal with numerical instabilities
// http://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process
for (int j = 0; j < iteration; j++)
{
double sum = 0.0;
for (int k = 0; k < v.Length; k++)
{
sum += v[k] * V[k, i];
}
for (int k = 0; k < v.Length; k++)
{
v[k] -= sum * V[k, j];
}
}
}
// Normalize v
double norm_v = Norm.Euclidean(v);
for (int i = 0; i < v.Length; i++)
{
v[i] /= norm_v;
}
// Save iteration
R.SetColumn(iteration, r);
U.SetColumn(iteration, u);
Q.SetColumn(iteration, q);
T.SetColumn(iteration, t);
P.SetColumn(iteration, p);
V.SetColumn(iteration, v);
// Explained variance
varX[iteration] = p.InnerProduct(p);
varY[iteration] = q.InnerProduct(q);
// Covariance matrix deflaction
// Cov = Cov - vi*(vi'*Cov);
double[,] d = new double[xcols, ycols];
for (int i = 0; i < xcols; i++)
{
for (int j = 0; j < xcols; j++)
{
for (int k = 0; k < ycols; k++)
{
d[i, k] += v[i] * v[j] * covariance[j, k];
}
}
}
for (int i = 0; i < xcols; i++)
{
for (int j = 0; j < ycols; j++)
{
covariance[i, j] -= d[i, j];
}
}
// Vi = V(:,1:i);
// Cov = Cov - Vi*(Vi'*Cov);
d = new double[iteration + 1, ycols];
for (int i = 0; i < iteration + 1; i++)
{
for (int j = 0; j < ycols; j++)
{
for (int k = 0; k < xcols; k++)
{
d[i, j] += V[k, i] * covariance[k, j];
}
}
}
for (int i = 0; i < iteration + 1; i++)
{
for (int j = 0; j < ycols; j++)
{
for (int k = 0; k < ycols; k++)
{
covariance[j, k] -= V[j, i] * d[i, k];
}
}
}
}
#endregion
// Orthogonalize scores (by convention)
for (int i = 0; i < factors; i++)
{
for (int s = 0; s < 2; s++)
{
for (int j = 0; j < i; j++)
{
double b = 0;
for (int k = 0; k < rows; k++)
{
b += U[k, i] * T[k, j];
}
for (int k = 0; k < rows; k++)
{
U[k, i] -= b * T[k, j];
}
}
}
}
// Set class variables
this.scoresX = T; // factor score matrix T
this.scoresY = U; // factor score matrix U
this.loadingsX = P; // loading matrix P, the loadings for X such that X = TP + F
this.loadingsY = Q; // loading matrix Q, the loadings for Y such that Y = TQ + E
this.weights = R; // the columns of R are weight vectors
this.coeffbase = R;
// Calculate variance explained proportions
this.componentProportionX = new double[factors];
this.componentProportionY = new double[factors];
double sumX = 0.0, sumY = 0.0;
for (int i = 0; i < rows; i++)
{
// Sum of squares for matrix X
for (int j = 0; j < xcols; j++)
{
sumX += X0[i, j] * X0[i, j];
}
// Sum of squares for matrix Y
for (int j = 0; j < ycols; j++)
{
sumY += Y0[i, j] * Y0[i, j];
}
}
// Calculate variance proportions
for (int i = 0; i < factors; i++)
{
componentProportionY[i] = varY[i] / sumY;
componentProportionX[i] = varX[i] / sumX;
}
}
//---------------------------------------------
#region Partial Least Squares Algorithms
/// <summary>
/// Computes PLS parameters using NIPALS algorithm.
/// </summary>
private void nipals(double[,] X0, double[,] Y0, int factors, double tolerance)
{
// Reference: Hervé Abdi, 2010
// http://www.utdallas.edu/~herve/abdi-wireCS-PLS2010.pdf
// Initialize and prepare the data
int rows = sourceX.GetLength(0);
int xcols = sourceX.GetLength(1);
int ycols = sourceY.GetLength(1);
// Initialize storage variables
double[,] X = (double[, ])X0.Clone();
double[,] Y = (double[, ])Y0.Clone();
double[,] T = new double[rows, factors];
double[,] U = new double[rows, factors];
double[,] P = new double[xcols, factors];
double[,] Q = new double[ycols, factors];
double[,] W = new double[xcols, xcols];
double[] B = new double[xcols];
double[] varX = new double[factors];
double[] varY = new double[factors];
// Initialize the algorithm
bool stop = false;
#region NIPALS
for (int iteration = 0; iteration < factors && !stop; iteration++)
{
// Select t as the largest column from X,
double[] t = X.GetColumn(largest(X));
// Select u as the largest column from Y.
double[] u = Y.GetColumn(largest(Y));
// Will store weights for X and Y
double[] w = new double[xcols];
double[] q = new double[ycols];
double norm_t = Norm.Euclidean(t);
#region Outer iteration
while (norm_t > 10e-15)
{
// Store initial t to check convergence
double[] t0 = (double[])t.Clone();
// Step 1. w ɑ X'u (estimate X weights).
// - w = X'*u;
w = new double[xcols];
for (int j = 0; j < xcols; j++)
{
for (int i = 0; i < rows; i++)
{
w[j] += X[i, j] * u[i];
}
}
// - Normalize w [w = w/norm(w)]
double norm_w = Norm.Euclidean(w);
w = w.Divide(norm_w);
// Step 2. t ɑ Xw (estimate X factor scores).
// - t = X*w
t = new double[rows];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < xcols; j++)
{
t[i] += X[i, j] * w[j];
}
}
// - Normalize t [t = t/norm(t)]
t = t.Divide(Norm.Euclidean(t));
// Step 3. q ɑ Y't (estimate Y weights).
// - q = Y'*t0;
q = new double[ycols];
for (int j = 0; j < ycols; j++)
{
for (int i = 0; i < rows; i++)
{
q[j] += Y[i, j] * t[i];
}
}
// - Normalize q [q = q/norm(q)]
double norm_q = Norm.Euclidean(q);
q = q.Divide(norm_q);
// Step 4. u = Yq (estimate Y scores).
// - u = Y*q;
u = new double[rows];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < ycols; j++)
{
u[i] += Y[i, j] * q[j];
}
}
// Recalculate norm of the difference
norm_t = 0.0;
for (int i = 0; i < rows; i++)
{
double d = (t0[i] - t[i]);
norm_t += d * d;
}
norm_t = System.Math.Sqrt(norm_t);
}
#endregion
// Compute factor loadings as p = X'*t
double[] p = new double[xcols];
for (int j = 0; j < xcols; j++)
{
for (int i = 0; i < rows; i++)
{
p[j] += X[i, j] * t[i];
}
}
// Compute the regression in latent space as b = t'u
double b = u.InnerProduct(t);
// Calculate explained variances
varY[iteration] = b * b;
varX[iteration] = p.InnerProduct(p);
// Perform deflaction of X and Y
for (int i = 0; i < rows; i++)
{
// Deflate X as X = X - t*p';
for (int j = 0; j < xcols; j++)
{
X[i, j] -= t[i] * p[j];
}
// Deflate Y as Y = Y - b*t*q';
for (int j = 0; j < ycols; j++)
{
Y[i, j] -= b * t[i] * q[j];
}
}
// Save iteration results
T.SetColumn(iteration, t);
P.SetColumn(iteration, p);
U.SetColumn(iteration, u);
Q.SetColumn(iteration, q);
W.SetColumn(iteration, w);
B[iteration] = b;
// Check for residuals as stop criteria
double[] norm_x = Norm.Euclidean(X);
double[] norm_y = Norm.Euclidean(Y);
stop = true;
for (int i = 0; i < norm_x.Length && stop == true; i++)
{
// If any of the residuals is higher than the tolerance
if (norm_x[i] > tolerance || norm_y[i] > tolerance)
{
stop = false;
}
}
}
#endregion
// R = inv(P')*B
this.coeffbase = Matrix.PseudoInverse(P.Transpose()).Multiply(Matrix.Diagonal(B));
// Set class variables
this.scoresX = T; // factor score matrix T
this.scoresY = U; // factor score matrix U
this.loadingsX = P; // loading matrix P, the loadings for X such that X = TP + F
this.loadingsY = Q; // loading matrix Q, the loadings for Y such that Y = TQ + E
this.weights = W; // the columns of W are weight vectors
// Calculate variance explained proportions
this.componentProportionX = new double[factors];
this.componentProportionY = new double[factors];
double sumX = 0.0, sumY = 0.0;
for (int i = 0; i < rows; i++)
{
// Sum of squares for matrix X
for (int j = 0; j < xcols; j++)
{
sumX += X0[i, j] * X0[i, j];
}
// Sum of squares for matrix Y
for (int j = 0; j < ycols; j++)
{
sumY += Y0[i, j] * Y0[i, j];
}
}
// Calculate variance proportions
for (int i = 0; i < factors; i++)
{
componentProportionY[i] = varY[i] / sumY;
componentProportionX[i] = varX[i] / sumX;
}
}
private double[] move(KDTree <int> tree, double[][] points, int index,
ConcurrentStack <double[]> modes,
Action <ICollection <NodeDistance <KDTreeNode <int> > >, double[]> computeMean)
{
double[] current = points[index];
double[] mean = new double[current.Length];
double[] shift = new double[current.Length];
// we will keep moving it in the
// direction of the density modes
int iterations = 0;
// until convergence or max iterations reached
while (iterations < MaxIterations)
{
iterations++;
// Get points near the current point
var neighbors = tree.Nearest(current, Bandwidth * 3, maximum);
// compute the mean on the region
computeMean(neighbors, mean);
// extract the mean shift vector
for (int j = 0; j < mean.Length; j++)
{
shift[j] = current[j] - mean[j];
}
// move the point towards a mode
for (int j = 0; j < mean.Length; j++)
{
current[j] = mean[j];
}
// Check if we are near to a maximum point
if (cut)
{
// Check if we are near a known mode
foreach (double[] mode in modes)
{
// compute the distance between points
// if they are near, they are duplicates
if (Distance.Distance(points[index], mode) < Bandwidth)
{
// Yes, we are close to a known mode. Let's substitute
// this point with a reference to this nearest mode
return(points[index] = mode); // and stop moving this point
}
}
}
// check for convergence: magnitude of the mean shift
// vector converges to zero (Comaniciu 2002, page 606)
if (Norm.Euclidean(shift) < Tolerance * Bandwidth)
{
break;
}
}
return(supress(points, index, modes));
}
/// <summary>
/// Divides the input data into clusters.
/// </summary>
///
/// <param name="points">The data where to compute the algorithm.</param>
/// <param name="threshold">The relative convergence threshold
/// for the algorithm. Default is 1e-3.</param>
/// <param name="maxIterations">The maximum number of iterations. Default is 100.</param>
///
public int[] Compute(double[][] points, double threshold, int maxIterations = 100)
{
// first, select initial points
double[][] seeds = createSeeds(points, 2 * Bandwidth);
var maxcandidates = new ConcurrentStack <double[]>();
// construct map of the data
tree = KDTree.FromData <int>(points, distance);
// now, for each initial point
global::Accord.Threading.Tasks.Parallel.For(0, seeds.Length,
#if DEBUG
new ParallelOptions()
{
MaxDegreeOfParallelism = 1
},
#endif
(index) =>
{
double[] point = seeds[index];
double[] mean = new double[point.Length];
double[] delta = new double[point.Length];
// we will keep moving it in the
// direction of the density modes
int iterations = 0;
// until convergence or max iterations reached
while (iterations < maxIterations)
{
iterations++;
// compute the shifted mean
computeMeanShift(point, mean);
// extract the mean shift vector
for (int j = 0; j < mean.Length; j++)
{
delta[j] = point[j] - mean[j];
}
// update the point towards a mode
for (int j = 0; j < mean.Length; j++)
{
point[j] = mean[j];
}
// Check if we are already near any maximum point
if (cut && nearest(point, maxcandidates) != null)
{
break;
}
// check for convergence: magnitude of the mean shift
// vector converges to zero (Comaniciu 2002, page 606)
if (Norm.Euclidean(delta) < threshold * Bandwidth)
{
break;
}
}
if (cut)
{
double[] match = nearest(point, maxcandidates);
if (match != null)
{
seeds[index] = match;
}
else
{
maxcandidates.Push(point);
}
}
});
// suppress non-maximum points
double[][] maximum = cut ? maxcandidates.ToArray() : supress(seeds);
// create a decision map using seeds
int[] seedLabels = classifySeeds(seeds, maximum);
tree = KDTree.FromData(seeds, seedLabels, distance);
// create the cluster structure
clusters = new MeanShiftClusterCollection(tree, maximum);
// label each point
return(clusters.Nearest(points));
}
private void radButton1_Click(object sender, EventArgs e)
{
if (input != null || output != null)
{
chart1.Series.Clear();
Error_Fun = new Series()
{
ChartType = SeriesChartType.Spline
};
chart1.Series.Add(Error_Fun);
List <DataPoint> err_function = new List <DataPoint>();
//double[,] andoutput = Matrix.Create(1, 4, 0d);
//oroutput[0, 0] = 1;
int nurons_num = (int)radTrackBar1.Value;
int max_iteration = Convert.ToInt16(radTextBox4.Text);
neuralNetwork net = new neuralNetwork(input, output, new int[] { nurons_num }, new string[] { radDropDownList1.Text.ToString(), radDropDownList2.Text.ToString() });
if (Intro.BP || Intro.BPM)
{
net.change_paramaters(Convert.ToDouble(radTextBox1.Text), Convert.ToDouble(radTextBox2.Text), Convert.ToDouble(radTextBox5.Text));
}
else
{
net.change_paramaters_levenberg(Convert.ToDouble(radTextBox1.Text), Convert.ToDouble(radTextBox2.Text), Convert.ToDouble(radTextBox3.Text), Convert.ToDouble(radTextBox6.Text));
}
net.init();
for (int i = 0; i < max_iteration; i++)
{
if (!Intro.Levenberg)
{
if (Intro.BP)
{
net.train("traingd", "onLine");
}
else if (Intro.BPM)
{
net.train("traingdm", "onLine");
}
net.get_class(new double[, ] {
{ 1.1, 2.1 }, { 5.1, 3.1 }, { 3.1, 6.1 }
});
double err = 0;
for (int ii = 0; ii < input.GetLength(1); ii++)
{
err += Norm.Euclidean(net.eval(input.GetColumn(ii)).Subtract(output.GetColumn(ii)));
}
err_function.Add(new DataPoint(i, err));
}
else
{
net.levenbergMarqardt();
double err = 0;
for (int ii = 0; ii < input.GetLength(1); ii++)
{
err += Norm.Euclidean(net.eval(input.GetColumn(ii)).Subtract(output.GetColumn(ii)));
}
err_function.Add(new DataPoint(i, err));
}
}
foreach (DataPoint p in err_function)
{
chart1.Series[0].Points.Add(p);
}
}
else
{
MessageBox.Show("Enter Input !");
}
}
private static void TestLinearASGD()
{
// http://leon.bottou.org/projects/sgd
string codebookPath = "codebook.bin";
string x_train_fn = "x_train.txt.gz";
string x_test_fn = "x_test.txt.gz";
Sparse <double>[] xTrain = null, xTest = null;
bool[] yTrain = null, yTest = null;
// Check if we have the precomputed dataset on disk
if (!File.Exists(x_train_fn) || !File.Exists(x_train_fn))
{
Console.WriteLine("Downloading dataset");
RCV1v2 rcv1v2 = new RCV1v2(@"C:\Temp\");
// Note: Leon Bottou's SGD inverts training and
// testing when benchmarking in this dataset
var trainWords = rcv1v2.Testing.Item1;
var testWords = rcv1v2.Training.Item1;
string positiveClass = "CCAT";
yTrain = rcv1v2.Testing.Item2.Apply(x => x.Contains(positiveClass));
yTest = rcv1v2.Training.Item2.Apply(x => x.Contains(positiveClass));
TFIDF tfidf;
if (!File.Exists(codebookPath))
{
Console.WriteLine("Learning TD-IDF");
// Create a TF-IDF considering only words that
// exist in both the training and testing sets
tfidf = new TFIDF(testWords)
{
Tf = TermFrequency.Log,
Idf = InverseDocumentFrequency.Default,
};
// Learn the training set
tfidf.Learn(trainWords);
Console.WriteLine("Saving codebook");
tfidf.Save(codebookPath);
}
else
{
Console.WriteLine("Loading codebook");
Serializer.Load(codebookPath, out tfidf);
}
if (!File.Exists(x_train_fn))
{
// Transform and normalize training set
Console.WriteLine("Pre-processing training set");
xTrain = tfidf.Transform(trainWords, out xTrain);
Console.WriteLine("Post-processing training set");
xTrain = xTrain.Divide(Norm.Euclidean(xTrain, dimension: 1), result: xTrain);
Console.WriteLine("Saving training set to disk");
SparseFormat.Save(xTrain, yTrain, x_train_fn, compression: SerializerCompression.GZip);
}
if (!File.Exists(x_test_fn))
{
// Transform and normalize testing set
Console.WriteLine("Pre-processing testing set");
xTest = tfidf.Transform(testWords, out xTest);
Console.WriteLine("Post-processing testing set");
xTest = xTest.Divide(Norm.Euclidean(xTest, dimension: 1), result: xTest);
Console.WriteLine("Saving testing set to disk");
SparseFormat.Save(xTest, yTest, x_test_fn, compression: SerializerCompression.GZip);
}
}
else
{
Console.WriteLine("Loading dataset from disk");
if (xTrain == null || yTrain == null)
{
SparseFormat.Load(x_train_fn, out xTrain, out yTrain, compression: SerializerCompression.GZip);
}
if (xTest == null || yTest == null)
{
SparseFormat.Load(x_test_fn, out xTest, out yTest, compression: SerializerCompression.GZip);
}
}
int positiveTrain = yTrain.Count(x => x);
int positiveTest = yTest.Count(x => x);
int negativeTrain = yTrain.Length - positiveTrain;
int negativeTest = yTest.Length - positiveTest;
Console.WriteLine("Training samples: {0} [{1}+, {2}-]", positiveTrain + negativeTrain, positiveTrain, negativeTrain);
Console.WriteLine("Negative samples: {0} [{1}+, {2}-]", positiveTest + negativeTest, positiveTest, negativeTest);
// Create and learn a linear sparse binary support vector machine
var learn = new AveragedStochasticGradientDescent <Linear, Sparse <double> >()
{
MaxIterations = 5,
Tolerance = 0,
};
Console.WriteLine("Learning training set");
Stopwatch sw = Stopwatch.StartNew();
var svm = learn.Learn(xTrain, yTrain);
Console.WriteLine(sw.Elapsed);
Console.WriteLine("Predicting training set");
sw = Stopwatch.StartNew();
bool[] trainPred = svm.Decide(xTrain);
Console.WriteLine(sw.Elapsed);
var train = new ConfusionMatrix(trainPred, yTrain);
Console.WriteLine("Train acc: " + train.Accuracy);
Console.WriteLine("Predicting testing set");
sw = Stopwatch.StartNew();
bool[] testPred = svm.Decide(xTest);
Console.WriteLine(sw.Elapsed);
var test = new ConfusionMatrix(testPred, yTest);
Console.WriteLine("Test acc: " + test.Accuracy);
}
//---------------------------------------------
#region FastICA Algorithms
/// <summary>
/// Deflation iterative algorithm.
/// </summary>
/// <returns>
/// Returns a matrix in which each row contains
/// the mixing coefficients for each component.
/// </returns>
private double[,] deflation(double[,] X, int components, double[,] init)
{
int n = X.GetLength(0);
int m = X.GetLength(1);
// Algorithm initialization
double[,] W = new double[components, m];
double[] wx = new double[n];
double[] gwx = new double[n];
double[] dgwx = new double[n];
// For each component to be computed,
for (int i = 0; i < components; i++)
{
// Will compute each of the basis vectors
// invidually and sequentially, re-using
// previous computations to form basis W.
//
// Initialization
int iterations = 0;
bool stop = false;
double[] w = init.GetRow(i);
double[] w0 = init.GetRow(i);
do // until convergence
{
// Deflaction
for (int u = 0; u < i; u++)
{
double k = 0;
for (int j = 0; j < m; j++)
k += w0[j] * W[u, j];
for (int j = 0; j < m; j++)
w[j] = w0[j] - k * W[u, j];
}
// Normalize
w = w.Divide(Norm.Euclidean(w));
// Gets the maximum absolute change in the parameters
double delta = System.Math.Abs(System.Math.Abs(Matrix.Sum(w.ElementwiseMultiply(w0))) - 1);
// Check for convergence
if (!(delta > tolerance && iterations < maxIterations))
{
stop = true;
}
else
{
// Advance to the next iteration
w0 = w; w = new double[m];
iterations++;
// Compute wx = w*x
for (int j = 0; j < n; j++)
{
double s = 0;
for (int k = 0; k < m; k++)
s += w0[k] * X[j, k];
wx[j] = s;
}
// Compute g(w*x) and g'(w*x)
contrast.Evaluate(wx, gwx, dgwx);
// Compute E{ x*g(w*x) }
double[] means = new double[m];
for (int j = 0; j < m; j++)
{
for (int k = 0; k < n; k++)
means[j] += X[k, j] * gwx[k];
means[j] /= n;
}
// Compute E{ g'(w*x) }
double mean = GABIZ.Base.Statistics.Tools.Mean(dgwx);
// Compute next update for w
for (int j = 0; j < m; j++)
w[j] = means[j] - w0[j] * mean;
}
} while (!stop);
// Store the just computed component
// in the resulting component matrix.
W.SetRow(i, w);
}
// Return the component basis matrix
return W; // vectors stored as rows.
}
private unsafe double minimize()
{
if (Function == null)
{
throw new InvalidOperationException(
"The function to be minimized has not been defined.");
}
if (Gradient == null)
{
throw new InvalidOperationException(
"The gradient function has not been defined.");
}
// Initialization
int n = numberOfVariables, m = corrections;
// Make initial evaluation
f = getFunction(x);
g = getGradient(x);
this.iterations = 0;
this.evaluations = 1;
// Obtain initial Hessian
double[] diagonal = null;
if (Diagonal != null)
{
diagonal = getDiagonal();
}
else
{
diagonal = new double[n];
for (int i = 0; i < diagonal.Length; i++)
{
diagonal[i] = 1.0;
}
}
fixed(double *w = work)
{
// The first N locations of the work vector are used to
// store the gradient and other temporary information.
double *rho = &w[n]; // Stores the scalars rho.
double *alpha = &w[n + m]; // Stores the alphas in computation of H*g.
double *steps = &w[n + 2 * m]; // Stores the last M search steps.
double *delta = &w[n + 2 * m + n * m]; // Stores the last M gradient differences.
// Initialize work vector
for (int i = 0; i < g.Length; i++)
{
steps[i] = -g[i] * diagonal[i];
}
// Initialize statistics
double gnorm = Norm.Euclidean(g);
double xnorm = Norm.Euclidean(x);
double stp = 1.0 / gnorm;
double stp1 = stp;
// Initialize loop
int nfev, point = 0;
int npt = 0, cp = 0;
bool finish = false;
// Make initial progress report with initialization parameters
if (Progress != null)
{
Progress(this, new OptimizationProgressEventArgs
(iterations, evaluations, g, gnorm, x, xnorm, f, stp, finish));
}
// Start main
while (!finish)
{
iterations++;
double bound = iterations - 1;
if (iterations != 1)
{
if (iterations > m)
{
bound = m;
}
double ys = 0;
for (int i = 0; i < n; i++)
{
ys += delta[npt + i] * steps[npt + i];
}
// Compute the diagonal of the Hessian
// or use an approximation by the user.
if (Diagonal != null)
{
diagonal = getDiagonal();
}
else
{
double yy = 0;
for (int i = 0; i < n; i++)
{
yy += delta[npt + i] * delta[npt + i];
}
double d = ys / yy;
for (int i = 0; i < n; i++)
{
diagonal[i] = d;
}
}
// Compute -H*g using the formula given in:
// Nocedal, J. 1980, "Updating quasi-Newton matrices with limited storage",
// Mathematics of Computation, Vol.24, No.151, pp. 773-782.
cp = (point == 0) ? m : point;
rho[cp - 1] = 1.0 / ys;
for (int i = 0; i < n; i++)
{
w[i] = -g[i];
}
cp = point;
for (int i = 1; i <= bound; i += 1)
{
if (--cp == -1)
{
cp = m - 1;
}
double sq = 0;
for (int j = 0; j < n; j++)
{
sq += steps[cp * n + j] * w[j];
}
double beta = alpha[cp] = rho[cp] * sq;
for (int j = 0; j < n; j++)
{
w[j] -= beta * delta[cp * n + j];
}
}
for (int i = 0; i < diagonal.Length; i++)
{
w[i] *= diagonal[i];
}
for (int i = 1; i <= bound; i += 1)
{
double yr = 0;
for (int j = 0; j < n; j++)
{
yr += delta[cp * n + j] * w[j];
}
double beta = alpha[cp] - rho[cp] * yr;
for (int j = 0; j < n; j++)
{
w[j] += beta * steps[cp * n + j];
}
if (++cp == m)
{
cp = 0;
}
}
npt = point * n;
// Store the search direction
for (int i = 0; i < n; i++)
{
steps[npt + i] = w[i];
}
stp = 1;
}
// Save original gradient
for (int i = 0; i < g.Length; i++)
{
w[i] = g[i];
}
// Obtain the one-dimensional minimizer of f by computing a line search
mcsrch(x, ref f, ref g, &steps[point * n], ref stp, out nfev, diagonal);
// Register evaluations
evaluations += nfev;
// Compute the new step and
// new gradient differences
for (int i = 0; i < g.Length; i++)
{
steps[npt + i] *= stp;
delta[npt + i] = g[i] - w[i];
}
if (++point == m)
{
point = 0;
}
// Check for termination
gnorm = Norm.Euclidean(g);
xnorm = Norm.Euclidean(x);
xnorm = Math.Max(1.0, xnorm);
if (gnorm / xnorm <= tolerance)
{
finish = true;
}
if (Progress != null)
{
Progress(this, new OptimizationProgressEventArgs
(iterations, evaluations, g, gnorm, x, xnorm, f, stp, finish));
}
}
}
return(f); // return the minimum value found (at solution x)
}
