/// <summary>
/// Returns a sorted list of EigenObjects sorted by their corresponding comparator implemention (eigenvalue in our case)
/// </summary>
/// <param name="Decomposition">Decomposition after solving the GEVP</param>
/// <returns></returns>
private List <EigenObject> GetSortedEigenObjects(IEigenvalueDecomposition Decomposition)
{
List <EigenObject> Res = new List <EigenObject>();
IMatrix Eigenvectors = Decomposition.EigenvectorMatrix;
for (int j = 0; j < Eigenvectors.Columns; j++)
{
EigenObject Eigen = new EigenObject();
double[] eigenvector = new double[Eigenvectors.Rows];
double magnitude = 0.0;
double eigenvalue = Decomposition.RealEigenvalues[j];
for (int i = 0; i < Eigenvectors.Rows; i++)
{
eigenvector[i] = Eigenvectors[i, j];
magnitude += Eigenvectors[i, j] * Eigenvectors[i, j];
}
magnitude = Math.Sqrt(magnitude);
Eigen.Magnitude = magnitude;
Eigen.Eigenvalue = eigenvalue;
Eigen.Eigenvector = eigenvector;
Res.Add(Eigen);
}
Res.Sort();
return(Res);
}
public void Train(int newDim)
{
CalculateMeansForAllClasses();
meanImage = CalculateMean(this.FaceList); //Mean image of all data
SW = CalculateWithinclassScatter();
IMatrix SB = CalculateBetweenclassScatter();
IMatrix Res = SW.Inverse.Multiply(SB);
IEigenvalueDecomposition Decomposition = Res.GetEigenvalueDecomposition();
List <EigenObject> Eigens = GetSortedEigenObjects(Decomposition);
Console.WriteLine(Eigens.Count);
WMatrix = GetLDABase(Eigens, newDim); //The weighted matrix
ProjectedMatrix = WMatrix.Transpose().Multiply(DataMatrix); //Projected samples
ComputeLDAProjectionForList(this.FaceList);
}
/// <summary>
/// Trains the PCA Classifier with the data in the given folder
/// </summary>
/// <param name="NewDimensionality"> Desired new vector space dimension</param>
public void Train(int NewDimensionality)
{
LoadImageMatrix();
if (ImagesAsMatrix == null)
{
throw new Exception("Images were not loaded to Matrix correctly");
}
IMatrix Adjusted = MeanAdjust(this.ImagesAsMatrix);
IMatrix Covariance = CalculateCovarianceMatrix(Adjusted);
IEigenvalueDecomposition Decomposition = Covariance.GetEigenvalueDecomposition(); //Eigenvalues are sorted, they are stack column-wise
EigenVectors = GetDesiredCountEigenvector(Decomposition, NewDimensionality);
EigenTransformationMatrix = ImagesAsMatrix.Multiply(EigenVectors);
EigenTransformationMatrix = NormalizeByColumn(EigenTransformationMatrix);
PopulateEigenFaceList();
CalculateProjectedImages(this.DataSet); //Calculating the projection of all images in the new basis space
this.IsTrained = true;
}
//-------------------------------------------------
//---------------------ComputeEigenValues-------------------
private void ComputeEigenValuesEigenVectors()
{
int i, j;
int n = ImageList.Count; //Total number of images
Evals = new double[n]; //One EigenVal per Img
IMatrix Evecs = new Matrix(n, n);
IEigenvalueDecomposition eigen = Cov.GetEigenvalueDecomposition();
Evecs = eigen.EigenvectorMatrix;
Evals = eigen.RealEigenvalues;
//---Copy the Eigen values and vectors in EvEvec objects
//---for easier sorting by Eigen values.
double[] evcTemp = new double[n];
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
evcTemp[j] = Evecs[j, i];
EVList.Add(new EvEvec(Evals[i], evcTemp, n));
}
EVList.Sort(); // sorts, highest Eigen value in pos. 0
}
/// <summary>
/// After solving the GEVP, we have N eigenvectors forming the new basis. Retrieves the numEigenVectors (e.g. 20) eigenvectors corresponding
/// to the highest eigenvalues.
/// </summary>
/// <param name="Decomposition"> Decompositon of GEVP</param>
/// <param name="numEigenVectors"> Desire subset of most significant eigen vectors</param>
/// <returns></returns>
public IMatrix GetDesiredCountEigenvector(IEigenvalueDecomposition Decomposition, int numEigenVectors)
{
double[] eigenVector = new double[Decomposition.EigenvectorMatrix.Rows];
int eigenvaluesCount = Decomposition.RealEigenvalues.Length;
IMatrix Res = new Matrix(Decomposition.EigenvectorMatrix.Rows, numEigenVectors);
int k = 0;
for (int j = eigenvaluesCount - 1; j > eigenvaluesCount - numEigenVectors - 1; j--)
{
double sum = 0.0;
for (int i = 0; i < eigenVector.Length; i++)
{
eigenVector[i] = Decomposition.EigenvectorMatrix[i, j];
sum += eigenVector[i] * eigenVector[i];
Res[i, k] = Decomposition.EigenvectorMatrix[i, j];
}
k++;
EigenVectorList.Add(eigenVector);
}
return(Res);
}
public static void Main(String[] args)
{
IMatrix A = new Matrix(3, 3);
A[0, 0] = 2.0; A[0, 1] = 1.0; A[0, 2] = 2.0;
A[1, 0] = 1.0; A[1, 1] = 4.0; A[1, 2] = 0.0;
A[2, 0] = 2.0; A[2, 1] = 0.0; A[2, 2] = 8.0;
Console.WriteLine("A = ");
Console.WriteLine(A.ToString());
Console.WriteLine("A.Determinant = " + A.Determinant);
Console.WriteLine("A.Trace = " + A.Trace);
Console.WriteLine("A.Norm1 = " + A.Norm1);
Console.WriteLine("A.NormInfinite = " + A.InfinityNorm);
Console.WriteLine("A.NormFrobenius = " + A.FrobeniusNorm);
ISingularValueDecomposition svg = A.GetSingularValueDecomposition();
Console.WriteLine("A.Norm2 = " + svg.Norm2);
Console.WriteLine("A.Condition = " + svg.Condition);
Console.WriteLine("A.Rank = " + svg.Rank);
Console.WriteLine();
Console.WriteLine("A.Transpose = ");
Console.WriteLine(A.Transpose().ToString());
Console.WriteLine("A.Inverse = ");
Console.WriteLine(A.Inverse.ToString());
IMatrix I = A.Multiply(A.Inverse);
Console.WriteLine("I = A * A.Inverse = ");
Console.WriteLine(I.ToString());
IMatrix B = new Matrix(3, 3);
Console.WriteLine("B = ");
B[0, 0] = 2.0; B[0, 1] = 0.0; B[0, 2] = 0.0;
B[1, 0] = 1.0; B[1, 1] = 0.0; B[1, 2] = 0.0;
B[2, 0] = 2.0; B[2, 1] = 0.0; B[2, 2] = 0.0;
Console.WriteLine(B.ToString());
IMatrix X = A.Solve(B);
Console.WriteLine("A.Solve(B)");
Console.WriteLine(X.ToString());
IMatrix T = A.Multiply(X);
Console.WriteLine("A * A.Solve(B) = B = ");
Console.WriteLine(T.ToString());
Console.WriteLine("A = V * D * V");
IEigenvalueDecomposition eigen = A.GetEigenvalueDecomposition();
Console.WriteLine("D = ");
Console.WriteLine(eigen.DiagonalMatrix.ToString());
Console.WriteLine("lambda = ");
foreach (double eigenvalue in eigen.RealEigenvalues)
{
Console.WriteLine(eigenvalue);
}
Console.WriteLine();
Console.WriteLine("V = ");
Console.WriteLine(eigen.EigenvectorMatrix);
Console.WriteLine("V * D * V' = ");
Console.WriteLine(eigen.EigenvectorMatrix.Multiply(eigen.DiagonalMatrix).Multiply(eigen.EigenvectorMatrix.Transpose()));
Console.WriteLine("A * V = ");
Console.WriteLine(A.Multiply(eigen.EigenvectorMatrix));
Console.WriteLine("V * D = ");
Console.WriteLine(eigen.EigenvectorMatrix.Multiply(eigen.DiagonalMatrix));
}
