/// <summary> /// Computes the most likely label of a new given point. /// </summary> /// /// <param name="input">A point to be classified.</param> /// <param name="scores">The distance score for each possible class.</param> /// /// <returns>The most likely label for the given point.</returns> /// public virtual int Compute(T input, out double[] scores) { // Compute all distances for (int i = 0; i < inputs.Length; i++) { distances[i] = distance.Distance(input, inputs[i]); } int[] idx = distances.Bottom(k, inPlace: true); scores = new double[classCount]; for (int i = 0; i < idx.Length; i++) { int j = idx[i]; int label = outputs[j]; double d = distances[i]; // Convert to similarity measure scores[label] += 1.0 / (1.0 + d); } // Get the maximum weighted score int result; scores.Max(out result); return(result); }
public int Compute(double[] input, out double[] distances) { distances = new double[means.Length]; for (int i = 0; i < distances.Length; i++) { distances[i] = distance.Distance(input, means[i]); } int imin; distances.Min(out imin); return(imin); }
/// <summary> /// Get distance between two time series given a certain width. /// </summary> /// <param name="seriesA"></param> /// <param name="seriesB"></param> /// <param name="distance"></param> /// <param name="width"></param> /// <returns></returns> public static double Distance(List <T> seriesA, List <T> seriesB, IDistance <T> distance, int width) { // Initialize. var dtw = new double[seriesA.Count, seriesB.Count]; for (var i = 0; i < seriesA.Count; i++) { for (var j = 0; j < seriesB.Count; j++) { dtw[i, j] = Double.PositiveInfinity; } } dtw[0, 0] = 0; width = Math.Max(width, Math.Abs(seriesA.Count - seriesB.Count)); // Calculate. for (var i = 1; i < seriesA.Count; i++) { for (var j = (int)Math.Max(1, i - width); j < Math.Min(seriesB.Count, i + width); j++) { var cost = distance.Distance(seriesA[i], seriesB[j]); dtw[i, j] = cost + Math.Min(dtw[i - 1, j], Math.Min(dtw[i, j - 1], dtw[i - 1, j - 1])); } } return(dtw[seriesA.Count - 1, seriesB.Count - 1]); }
/// <summary> /// Get distance between two time series. /// </summary> /// <param name="seriesA"></param> /// <param name="seriesB"></param> /// <param name="distance"></param> /// <returns></returns> public static double Distance(List <T> seriesA, List <T> seriesB, IDistance <T> distance) { // Initialize. var dtw = new double[seriesA.Count + 1, seriesB.Count + 1]; for (var i = 1; i < seriesA.Count; i++) { dtw[i, 0] = Double.PositiveInfinity; } for (var i = 1; i < seriesB.Count; i++) { dtw[0, i] = Double.PositiveInfinity; } dtw[0, 0] = 0; // Calculate. for (var i = 1; i <= seriesA.Count; i++) { for (var j = 1; j <= seriesB.Count; j++) { var cost = distance.Distance(seriesA[i - 1], seriesB[j - 1]); dtw[i, j] = cost + Math.Min(dtw[i - 1, j], Math.Min(dtw[i, j - 1], dtw[i - 1, j - 1])); } } return(dtw[seriesA.Count - 1, seriesB.Count - 1]); }
internal static double[][] GetDistances(IDistance <double[], double[]> distance, double[][] points, double[][] centroids, int k, double[][] result) { for (int i = 0; i < result.Length; i++) { for (int j = 0; j < result[i].Length; j++) { result[i][j] = distance.Distance(points[j], centroids[GetIndex(k, i)]); } } return(result); }
public void DistanceMatrix(List <Point> points) { for (var customer = 0; customer < points.Count; customer++) { var dist_other_customers = new Dictionary <int, double>(); //a list to add the distance between the customer i and customer j for (var other_customer = customer + 1; other_customer < points.Count; other_customer++) { //calculate the distance between customer i and all the customers j. except where a> b & b > a in order to avoid duplicate values. var distance = distanceType.Distance(points[customer].Data, points[other_customer].Data); dist_other_customers.Add(other_customer, distance); //Add the current customer i and the distance between customer i and customer j to this list. } Distance_Matrix.Add(customer, dist_other_customers); //add the result of all the distance between the customers. } }
public void DistanceObjectToCentroids(List <Point> datapoints, List <Centroid> Centroids, IDistance distanceType) { // 1.foreach datapoint calculate the distance measure the distance of the centroids and datapoints. datapoints.ForEach(datapoint => { var centroidDistances = new List <(int, double)>(); Centroids.ForEach(Centroid => { //2. calculate the distance between the datapoint and the centroids. // var distanceCentroid = new DistanceFactory().ChooseTypeDistance(Centroid.Points, datapoint.Data, distanceType); var distanceCentroid = distanceType.Distance(Centroid.Points, datapoint.Data); //3. Add the distances between the centroid and the datapoint into a list centroidDistances.Add((Centroid.Id, distanceCentroid)); //Add the calculated distances between the customer and all centroids }); //.4 take the centroid with the least distance compared to the centroid and set the id of the centroid to the datapoint. datapoint.Centroid = centroidDistances.OrderBy(centroid => centroid.Item2).First().Item1; }); }
public double CalcSSE(List <Centroid> Centroids, List <Point> datapoints, int iteration, IDistance distanceType) { double SSE = 0; for (int i = 0; i < Centroids.Count; i++) { var clusterSet = datapoints.Where(vector => vector.Centroid == i).ToList(); foreach (var datapoint in clusterSet) { SSE += Math.Pow(distanceType.Distance(Centroids[i].Points, datapoint.Data), 2); } } if (LowestSSE < SSE) { LowestSSE = SSE; } // Console.WriteLine("SSE of iteration " + iteration + ":" + SSE); return(SSE); }
public void getdistance_test() { #region doc_getdistance // Let's say you have been using the static Distance.Euclidean() method in // your code, and now you would like to obtain a reference to a class that // implements the IDistance interface for this same distance, such that you // could pass it to some other method in the framework: double[] x = new double[] { 2, 4, 1 }; double[] y = new double[] { 0, 0, 0 }; double a = Distance.Euclidean(x, y); // should be 4.58257569495584 // Use the GetDistance method to obtain an IDistance that implements it: IDistance <double[]> obj = Distance.GetDistance <double[]>(Distance.Euclidean); // We can continue computing the same distances as before using: double b = obj.Distance(x, y); // should be 4.58257569495584 #endregion double expected = 4.58257569495584; Assert.AreEqual(a, expected); Assert.AreEqual(b, expected); }
/// <summary> /// Reverts a set of projected data into it's original form. Complete reverse /// transformation is not always possible and is not even guaranteed to exist. /// </summary> /// /// <remarks> /// <para> /// This method works using a closed-form MDS approach as suggested by /// Kwok and Tsang. It is currently a direct implementation of the algorithm /// without any kind of optimization. /// </para> /// <para> /// Reference: /// - http://cmp.felk.cvut.cz/cmp/software/stprtool/manual/kernels/preimage/list/rbfpreimg3.html /// </para> /// </remarks> /// /// <param name="data">The kpca-transformed data.</param> /// <param name="neighbors">The number of nearest neighbors to use while constructing the pre-image.</param> /// public double[,] Revert(double[,] data, int neighbors) { if (data == null) { throw new ArgumentNullException("data"); } if (sourceCentered == null) { throw new InvalidOperationException("The analysis must have been computed first."); } if (neighbors < 2) { throw new ArgumentOutOfRangeException("neighbors", "At least two neighbors are necessary."); } // Verify if the current kernel supports // distance calculation in feature space. IDistance distance = kernel as IDistance; if (distance == null) { throw new NotSupportedException("Current kernel does not support distance calculation in feature space."); } int rows = data.GetLength(0); double[,] reversion = new double[rows, sourceCentered.GetLength(1)]; // number of neighbors cannot exceed the number of training vectors. int nn = System.Math.Min(neighbors, sourceCentered.GetLength(0)); // For each point to be reversed for (int p = 0; p < rows; p++) { // 1. Get the point in feature space double[] y = data.GetRow(p); // 2. Select nn nearest neighbors of the feature space double[,] X = sourceCentered; double[] d2 = new double[Result.GetLength(0)]; int[] inx = new int[Result.GetLength(0)]; // 2.1 Calculate distances for (int i = 0; i < X.GetLength(0); i++) { inx[i] = i; d2[i] = distance.Distance(y, Result.GetRow(i).Submatrix(y.Length)); } // 2.2 Order them Array.Sort(d2, inx); // 2.3 Select nn neighbors inx = inx.Submatrix(nn); X = X.Submatrix(inx).Transpose(); // X is in input space d2 = d2.Submatrix(nn); // distances in input space // 3. Perform SVD // [U,L,V] = svd(X*H); // TODO: If X has more columns than rows, the SV decomposition should be // computed on the transpose of X and the left and right vectors should // be swapped. This should be fixed after more unit tests are elaborated. SingularValueDecomposition svd = new SingularValueDecomposition(X); double[,] U = svd.LeftSingularVectors; double[,] L = Matrix.Diagonal(nn, svd.Diagonal); double[,] V = svd.RightSingularVectors; // 4. Compute projections // Z = L*V'; double[,] Z = L.Multiply(V.Transpose()); // 5. Calculate distances // d02 = sum(Z.^2)'; double[] d02 = Matrix.Sum(Matrix.ElementwisePower(Z, 2)); // 6. Get the pre-image using z = -0.5*inv(Z')*(d2-d02) double[,] inv = Matrix.PseudoInverse(Z.Transpose()); double[] z = (-0.5).Multiply(inv).Multiply(d2.Subtract(d02)).Submatrix(U.GetLength(0)); // 8. Project the pre-image on the original basis // using x = U*z + sum(X,2)/nn; double[] x = (U.Multiply(z)).Add(Matrix.Sum(X.Transpose()).Multiply(1.0 / nn)); // 9. Store the computed pre-image. for (int i = 0; i < reversion.GetLength(1); i++) { reversion[p, i] = x[i]; } } // if the data has been standardized or centered, // we need to revert those operations as well if (this.Method == AnalysisMethod.Standardize) { // multiply by standard deviation and add the mean for (int i = 0; i < reversion.GetLength(0); i++) { for (int j = 0; j < reversion.GetLength(1); j++) { reversion[i, j] = (reversion[i, j] * StandardDeviations[j]) + Means[j]; } } } else if (this.Method == AnalysisMethod.Center) { // only add the mean for (int i = 0; i < reversion.GetLength(0); i++) { for (int j = 0; j < reversion.GetLength(1); j++) { reversion[i, j] = reversion[i, j] + Means[j]; } } } return(reversion); }