/// <summary> /// Computes the natural clustering of the resulting trajectories (behaviors) along with the behavioral entropy /// (diversity). /// </summary> /// <param name="evaluationUnits">The agent/maze evaluations to cluster and compute entropy.</param> /// <param name="clusterImprovementThreshold"> /// The number of cluster additions that are permitted without further /// maximization of silhouette width. When this is exceeded, the incremental cluster additions will stop and the /// number of clusters resulting in the highest silhouette width will be considered optimal. /// </param> /// <returns></returns> public static ClusterDiversityUnit CalculateNaturalClustering( IList<MazeNavigatorEvaluationUnit> evaluationUnits, int clusterImprovementThreshold) { Dictionary<int, double> clusterSilhoutteMap = new Dictionary<int, double>(); Tuple<int, double> clusterWithMaxSilhouetteWidth = null; // Always start with zero clusters and increment on first iteration of loop const int initClusterCnt = 0; // Only consider successful trials IList<MazeNavigatorEvaluationUnit> successfulEvaluations = evaluationUnits.Where(eu => eu.IsMazeSolved).ToList(); // Define the trajectory matrix in which to store all trajectory points for each trajectory // (this becomes a collection of observation vectors that's fed into k-means) double[][] trajectoryMatrix = new double[successfulEvaluations.Count][]; // Get the maximum observation vector length (max simulation runtime) // (multiplied by 2 to account for each timestep containing a 2-dimensional position) int maxObservationLength = successfulEvaluations.Max(x => x.NumTimesteps)*2; for (int idx = 0; idx < successfulEvaluations.Count; idx++) { // If there are few observations than the total elements in the observation vector, // fill out the vector with the existing observations and set the rest equal to the last // position in the simulation if (successfulEvaluations[idx].AgentTrajectory.Length < maxObservationLength) { trajectoryMatrix[idx] = successfulEvaluations[idx].AgentTrajectory.Concat( Enumerable.Repeat( successfulEvaluations[idx].AgentTrajectory[ successfulEvaluations[idx].AgentTrajectory.Length - 1], maxObservationLength - successfulEvaluations[idx].AgentTrajectory.Length)).ToArray(); } // If they are equal, just set the trajectory points else { trajectoryMatrix[idx] = successfulEvaluations[idx].AgentTrajectory; } } // Set the initial cluster count int clusterCount = initClusterCnt; // Continue loop until the maximum number of iterations without silhouette width improvement has elapsed // (also don't allow number of clusters to match the number of observations) while (clusterWithMaxSilhouetteWidth == null || (clusterSilhoutteMap.Count <= clusterImprovementThreshold || clusterSilhoutteMap.Where( csm => (csm.Key - initClusterCnt) >= clusterSilhoutteMap.Count - clusterImprovementThreshold) .Any( csm => csm.Value >= clusterWithMaxSilhouetteWidth.Item2)) && clusterCount < trajectoryMatrix.Length - 1) { // Increment cluster count clusterCount++; // Create a new k-means instance with the specified number of clusters var kmeans = new KMeans(clusterCount); // TODO: The below logic is in support of a work-around to an Accord.NET bug wherein // TODO: an internal random number generator sometimes generates out-of-bounds values // TODO: (i.e. a probability that is not between 0 and 1) // TODO: https://github.com/accord-net/framework/issues/259 // Use uniform initialization kmeans.UseSeeding = Seeding.Uniform; // Determine the resulting clusters var clusters = kmeans.Learn(trajectoryMatrix); // Compute the silhouette width for the current number of clusters double silhouetteWidth = ComputeSilhouetteWidth(clusters, trajectoryMatrix); // Compute silhouette width and add to map with the current cluster count clusterSilhoutteMap.Add(clusterCount, silhouetteWidth); // If greater than the max silhouette width, reset the cluster with the max if (clusterWithMaxSilhouetteWidth == null || silhouetteWidth > clusterWithMaxSilhouetteWidth.Item2) { clusterWithMaxSilhouetteWidth = new Tuple<int, double>(clusterCount, silhouetteWidth); } } // Rerun kmeans for the final cluster count var optimalClustering = new KMeans(clusterCount); // TODO: The below logic is in support of a work-around to an Accord.NET bug wherein // TODO: an internal random number generator sometimes generates out-of-bounds values // TODO: (i.e. a probability that is not between 0 and 1) // TODO: https://github.com/accord-net/framework/issues/259 // Use uniform initialization optimalClustering.UseSeeding = Seeding.Uniform; // Determine cluster assignments optimalClustering.Learn(trajectoryMatrix); double sumLogProportion = 0.0; // Compute the shannon entropy of the population for (int idx = 0; idx < optimalClustering.Clusters.Count; idx++) { sumLogProportion += optimalClustering.Clusters[idx].Proportion* Math.Log(optimalClustering.Clusters[idx].Proportion, 2); } // Multiply by negative one to get the Shannon entropy double shannonEntropy = sumLogProportion*-1; // Return the resulting cluster diversity info return new ClusterDiversityUnit(optimalClustering.Clusters.Count, shannonEntropy); }
/// <summary> /// The cluster. /// </summary> /// <param name="clustersCount"> /// The clusters count. /// </param> /// <param name="data"> /// The data. /// </param> /// <returns> /// The <see cref="T:int[]"/>. /// </returns> public int[] Cluster(int clustersCount, double[][] data) { KMeans kMeans = new KMeans(clustersCount); var clusters = kMeans.Learn(data); var result = new int[data.Length]; for (int i = 0; i < result.Length; i++) { result[i] = clusters.Decide(data[i]); } return result; }
public static List <Point2D> FindBaseLocation(this List <Unit> self) { List <Point2D> ret = new List <Point2D>(); List <Unit> gas = self.GetUnits(UNIT_TYPEID.NEUTRAL_VESPENEGEYSER); double[][] data = new double[gas.Count][]; for (int i = 0; i < gas.Count; i++) { data[i] = new double[] { gas[i].Pos.X, gas[i].Pos.Y }; } KMeans kmeans = new KMeans(k: gas.Count / 2); KMeansClusterCollection clusters = kmeans.Learn(data); for (int i = 0; i < kmeans.Centroids.Length; i++) { ret.Add(new Point2D { X = (float)kmeans.Centroids[i][0], Y = (float)kmeans.Centroids[i][1] }); } return(ret); }
private async Task RetrainAsync(Expression <Func <Leg, bool> > predicate) { await _geocodingDbSync.UpdateAllAsync(); KMeans kMeans = new KMeans(NumberOfClusters) { Distance = new GeographicDistance() }; double[][] dataset = GetDataset(predicate == null ? await _legRepository.ListAsync() : await _legRepository.ListAsync(predicate)); ClusterCollection = await Task.Run(() => kMeans.Learn(dataset)); IEnumerable <DateTime> startTimes = (await _legRepository.ListAsync(predicate)).Select(leg => leg.StartTime); _RetrainedEarliestDate = startTimes.Min(); _RetrainedLatestDate = startTimes.Max(); _LastRetrained = DateTime.Now; }
//sets the values in kmeansArr[] public static void runKMeans(ref Group[] gs) { int numGroups = gs.Count(); // Declaring and intializing array for K-Means double[][] observations = new double[numGroups][]; for (int i = 0; i < observations.Length; i++) { observations[i] = new double[2]; observations[i][0] = gs[i].destination.coords[0]; observations[i][1] = gs[i].destination.coords[1]; } int numClusters = (gs.Count() / 6) + 1; //THIS WHAT WE WANT? KMeans km = new KMeans(numClusters); KMeansClusterCollection clust = km.Learn(observations); kmeansArr = clust.Decide(observations); }
static void Main(string[] args) { var filePath = @"D:\Repo\Magisterka\zbiory\glass1.dat"; string [][] data = File.ReadLines(filePath).Where(line => line != "").Select(x => x.Split(';')).ToArray(); double [][] dataNumber = ConvertArray(data); Dictionary <int, int> population = GetPopulationOfClassess(dataNumber); int majorityLabel = GetLabelOfMajorityClass(population); int minorityLabel = GetLabelOfMinorityClass(population); int majorityPopulation = population[majorityLabel]; int minorityPopulation = population[minorityLabel]; double[][] majorityClass = GetWholeClass(majorityLabel, dataNumber, majorityPopulation); double[][] minorityClass = GetWholeClass(minorityLabel, dataNumber, minorityPopulation); double[][] majorityWithoutLabels = GetSamplesWithoutLabels(majorityClass); KMeans kmeans = new KMeans(k: minorityPopulation); var clusters = kmeans.Learn(majorityWithoutLabels); double[][] centroids = clusters.Centroids; WriteToFile(centroids, minorityClass, majorityLabel); }
private List <Point3d> KMeansReduce(List <Point3d> points, Mesh m) { List <Point3d> reduced = new List <Point3d>(); Polyline[] outlines = m.GetOutlines(Plane.WorldXY); double area = 0; foreach (Polyline pl in outlines) { AreaMassProperties amp = AreaMassProperties.Compute(pl.ToNurbsCurve()); area += amp.Area; } int nClusters = (int)(area / 1000000); List <double[]> pts2d = new List <double[]>(); if (nClusters == 0) { double minZ = points.Min(x => x.Z); reduced.Add(points.Find(p => p.Z == minZ)); return(reduced); } foreach (Point3d p in points) { pts2d.Add(new double[] { p.X, p.Y }); } if (points.Count < nClusters) { return(points); } KMeans kmeans = new KMeans(k: nClusters); // Compute and retrieve the data centroids var clusters = kmeans.Learn(pts2d.ToArray()); // Use the centroids to parition all the data int[] labels = clusters.Decide(pts2d.ToArray()); return(reduced); }
// Called by LandMap.GetZones (), returns number of subregions public int ClusterLocationsAccordKMeans(MapPoint[,] points) { // K-means cluster algorithm to separate locations in the regions int regionId = 0; for (int isleId = 0; isleId < regions.Count; isleId++) { MapRegion region = regions[isleId]; double[][] tileLocations = new double[region.turf.Count][]; for (int i = 0; i < tileLocations.Length; i++) { tileLocations[i] = new double[2]; tileLocations[i][0] = region.turf[i].x; tileLocations[i][1] = region.turf[i].y; } int k = InitializeNumOfK(region.turf.Count); Debug.Log(k + " centroid(s)"); KMeans kmeans = new KMeans(k); KMeansClusterCollection clusters = kmeans.Learn(tileLocations); int[] labels = clusters.Decide(tileLocations); Debug.Log("Number of labels (clusters) = " + labels.Length); for (int i = 0; i < labels.Length; i++) { points[(int)tileLocations[i][0], (int)tileLocations[i][1]].areaValue = regionId + labels[i]; } regionId += k; } return(regionId); }
public static Output Clustering(double[,] patches, int numberOfClusters, string pathToCentroidFile) { // "Generator.Seed" sets a random seed for the framework's main internal number generator, which // gets a reference to the random number generator used internally by the Accord.NET classes and methods. // If set to a value less than or equal to zero, all generators will start with the same fixed seed, even among multiple threads. // If set to any other value, the generators in other threads will start with fixed, but different, seeds. // this method should be called before other computations. Accord.Math.Random.Generator.Seed = 0; KMeans kmeans = new KMeans(k: numberOfClusters) { UseSeeding = Seeding.KMeansPlusPlus, Distance = default(Cosine), }; var clusters = kmeans.Learn(patches.ToJagged()); // get the cluster size Dictionary <int, double> clusterIdSize = new Dictionary <int, double>(); Dictionary <int, double[]> clusterIdCentroid = new Dictionary <int, double[]>(); foreach (var clust in clusters.Clusters) { clusterIdSize.Add(clust.Index, clust.Proportion); clusterIdCentroid.Add(clust.Index, clust.Centroid); } Csv.WriteToCsv(pathToCentroidFile.ToFileInfo(), clusterIdCentroid); var output = new Output() { ClusterIdCentroid = clusterIdCentroid, ClusterIdSize = clusterIdSize, Clusters = clusters, }; return(output); }
public int[] KMeansClustering(List <double> column) { var orderedColumn = column.OrderBy(x => x).ToList(); double maxValue = orderedColumn.Last(); double smallestValue = orderedColumn.First(); KMeans kmeans = new KMeans(k: 10); double[][] data = new double[column.Count][]; for (int i = 0; i < column.Count; i++) { data[i] = new double[] { 1, column[i] }; } // Compute and retrieve the data centroids var clusters = kmeans.Learn(data); // Use the centroids to parition all the data int[] labels = clusters.Decide(data); return(labels); }
private void cluster(ushort j) { cvsbmp = UtilFn.BitmapImage2Bitmap(images[j]); var imageToArray = new ImageToArray(min: -1, max: +1); var arrayToImage = new ArrayToImage(cvsbmp.Width, cvsbmp.Height, min: -1, max: +1); int kk; double[][] pixels; imageToArray.Convert(cvsbmp, out pixels); try { kk = Int16.Parse(kCluster.Text); } catch (Exception) { return; } if (kk < 1) { return; } KMeans kmeans = new KMeans(k: kk) { Distance = new SquareEuclidean(), Tolerance = 0.05 }; var clusters = kmeans.Learn(pixels); int[] labels = clusters.Decide(pixels); double[][] replaced = pixels.Apply((x, i) => clusters.Centroids[labels[i]]); Bitmap result; arrayToImage.Convert(replaced, out result); imagesEdited.Add(converter.Convert(result, Type.GetType("BitmapImage"), null, null) as BitmapImage); }
private void runKMeans() { int k = (int)numClusters.Value; Bitmap image = img; ImageToArray imageToArray = new ImageToArray(min: -1, max: +1); ArrayToImage arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1); double[][] pixels; imageToArray.Convert(image, out pixels); KMeans kmeans = new KMeans(k, new SquareEuclidean()) { Tolerance = 0.05 }; int[] idx = kmeans.Learn(pixels).Decide(pixels); pixels.Apply((x, i) => kmeans.Clusters.Centroids[idx[i]], result: pixels); Bitmap result; arrayToImage.Convert(pixels, out result); pictureBox1.Image = result; }
private static string GenerateColorPalette(byte[] imgData, int numClusters) { var img = Cv2.ImDecode(imgData, ImreadModes.Color); var colors = new List <Vec3b>(); var mat3 = new Mat <Vec3b>(img); var indexer = mat3.GetIndexer(); for (int y = 0; y < img.Height / 10; y++) { for (int x = 0; x < img.Width / 10; x++) { var color = indexer[y, x]; byte temp = color.Item0; color.Item0 = color.Item2; color.Item2 = temp; indexer[y, x] = color; colors.Add(indexer[y, x]); } } var observations = colors.Select(c => new double[] { c.Item0, c.Item1, c.Item2 }).ToArray(); var kmeans = new KMeans(numClusters, new SquareEuclidean()) { Tolerance = 0.05 }; var clusters = kmeans.Learn(observations); var computedColors = clusters.Select(c => new Color { R = (byte)Math.Round(c.Centroid[0], 0), G = (byte)Math.Round(c.Centroid[1], 0), B = (byte)Math.Round(c.Centroid[2], 0) }).ToList(); string json = JsonConvert.SerializeObject(computedColors, Formatting.Indented); return(json); }
/// <summary> /// Runs the K-Means algorithm. /// </summary> /// private void runKMeans() { // Retrieve the number of clusters int k = (int)numClusters.Value; // Load original image Bitmap image = Properties.Resources.leaf; // Create converters ImageToArray imageToArray = new ImageToArray(min: -1, max: +1); ArrayToImage arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1); // Transform the image into an array of pixel values double[][] pixels; imageToArray.Convert(image, out pixels); // Create a K-Means algorithm using given k and a // square Euclidean distance as distance metric. KMeans kmeans = new KMeans(k, new SquareEuclidean()) { Tolerance = 0.05 }; // Compute the K-Means algorithm until the difference in // cluster centroids between two iterations is below 0.05 int[] idx = kmeans.Learn(pixels).Decide(pixels); // Replace every pixel with its corresponding centroid pixels.Apply((x, i) => kmeans.Clusters.Centroids[idx[i]], result: pixels); // Show resulting image in the picture box Bitmap result; arrayToImage.Convert(pixels, out result); pictureBox.Image = result; }
public void learn_test() { #region doc_learn Accord.Math.Random.Generator.Seed = 0; // Declare some observations double[][] observations = { new double[] { -5, -2, -1 }, new double[] { -5, -5, -6 }, new double[] { 2, 1, 1 }, new double[] { 1, 1, 2 }, new double[] { 1, 2, 2 }, new double[] { 3, 1, 2 }, new double[] { 11, 5, 4 }, new double[] { 15, 5, 6 }, new double[] { 10, 5, 6 }, }; // Create a new K-Means algorithm KMeans kmeans = new KMeans(k: 3); // Compute and retrieve the data centroids var clusters = kmeans.Learn(observations); // Use the centroids to parition all the data int[] labels = clusters.Decide(observations); #endregion Assert.AreEqual(labels[0], labels[1]); Assert.AreEqual(labels[2], labels[3]); Assert.AreEqual(labels[2], labels[4]); Assert.AreEqual(labels[2], labels[5]); Assert.AreEqual(labels[6], labels[7]); Assert.AreEqual(labels[6], labels[8]); Assert.AreNotEqual(labels[0], labels[2]); Assert.AreNotEqual(labels[2], labels[6]); Assert.AreNotEqual(labels[0], labels[6]); int[] labels2 = kmeans.Clusters.Decide(observations); Assert.IsTrue(labels.IsEqual(labels2)); // the data must not have changed! double[][] orig = { new double[] { -5, -2, -1 }, new double[] { -5, -5, -6 }, new double[] { 2, 1, 1 }, new double[] { 1, 1, 2 }, new double[] { 1, 2, 2 }, new double[] { 3, 1, 2 }, new double[] { 11, 5, 4 }, new double[] { 15, 5, 6 }, new double[] { 10, 5, 6 }, }; Assert.IsTrue(orig.IsEqual(observations)); var c = new KMeansClusterCollection.KMeansCluster[clusters.Count]; int i = 0; foreach (var cluster in clusters) { c[i++] = cluster; } for (i = 0; i < c.Length; i++) { Assert.AreSame(c[i], clusters[i]); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { int i, j, k; bool IsPointData = false; GH_Structure <IGH_Goo> data = new GH_Structure <IGH_Goo>(); GH_Structure <IGH_GeometricGoo> geo = new GH_Structure <IGH_GeometricGoo>(); List <int> numCluster = new List <int>(); if (!DA.GetDataTree(0, out data)) { return; } if (!DA.GetDataTree(1, out geo)) { return; } if (!DA.GetDataList(2, numCluster)) { return; } data.Simplify(GH_SimplificationMode.CollapseAllOverlaps); DataTree <IGH_Goo> outputData = new DataTree <IGH_Goo>(); DataTree <IGH_GeometricGoo> outputGeo = new DataTree <IGH_GeometricGoo>(); DataTree <Point3d> outputCentroids = new DataTree <Point3d>(); for (i = 0; i < data.Branches.Count; i++) { double[] x = new double[data.Branches[i].Count]; double[] y = new double[data.Branches[i].Count]; double[] z = new double[data.Branches[i].Count]; for (j = 0; j < data.Branches[i].Count; j++) { if (data.Branches[i][j] is GH_Point) { IsPointData = true; GH_Point target = new GH_Point(); if (GH_Convert.ToGHPoint(data.Branches[i][j], GH_Conversion.Both, ref target)) { x[j] = target.Value.X; y[j] = target.Value.Y; z[j] = target.Value.Z; } } else { break; } } if (IsPointData) { List <double[]> datalist = new List <double[]> { x, y, z }; double[][] _data = ArrayConvert.To2DArray(datalist); KMeans m = new KMeans(numCluster[i]); KMeansClusterCollection cluster = m.Learn(_data); int[] labels = cluster.Decide(_data); double[][] centroids = m.Centroids; for (j = 0; j < data.Branches[i].Count; j++) { GH_Path path = new GH_Path(i, labels[j]); outputData.Add(data.Branches[i][j], path); outputGeo.Add(geo.Branches[i][j], path); } for (k = 0; k < centroids.Length; k++) { outputCentroids.Add(new Point3d(centroids.ElementAt(k).ElementAt(0), centroids.ElementAt(k).ElementAt(1), centroids.ElementAt(k).ElementAt(2)), new GH_Path(k)); } } else { break; } } if (!IsPointData) { GH_Path oldPath = new GH_Path(); GH_Path newPath = new GH_Path(); int DataGroupCount = 0; for (i = 0; i < data.PathCount; i++) { if (data.Paths[i].Indices.Length == 1) { DataGroupCount = 1; break; } else { int[] pp = new int[data.Paths[i].Indices.Length - 1]; for (j = 0; j < data.Paths[i].Indices.Length - 1; j++) { pp[j] = data.Paths[i].Indices[j]; } newPath.Indices = pp; if (newPath != oldPath) { DataGroupCount++; oldPath = newPath; } newPath = new GH_Path(); } } for (i = 0; i < DataGroupCount; i++) { List <double[]> datalist = new List <double[]>(); for (j = 0; j < data.Branches.Count / DataGroupCount; j++) { double[] values = new double[data.Branches[DataGroupCount * i + j].Count]; for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++) { if (data.Branches[DataGroupCount * i + j][k] is GH_Number) { if (GH_Convert.ToDouble(data.Branches[DataGroupCount * i + j][k], out double value, GH_Conversion.Both)) { values[k] = value; } } else { break; } } datalist.Add(values); } double[][] _data = ArrayConvert.ToDoubleArray(datalist); KMeans m = new KMeans(numCluster[0]); KMeansClusterCollection cluster = m.Learn(_data); int[] labels = cluster.Decide(_data); for (j = 0; j < labels.Length; j++) { List <IGH_Goo> numbers = new List <IGH_Goo>(); List <IGH_GeometricGoo> geos = new List <IGH_GeometricGoo>(); for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++) { numbers.Add(data.Branches[DataGroupCount * i + j][k]); geos.Add(geo.Branches[DataGroupCount * i + j][k]); } GH_Path path = new GH_Path(i, j, labels[j]); outputData.AddRange(numbers, path); outputGeo.AddRange(geos, path); } } } DA.SetDataTree(0, outputData); DA.SetDataTree(1, outputGeo); DA.SetDataTree(2, outputCentroids); }
/// <summary> /// Train on number of clusters using gap statistic /// </summary> private async Task ComputeK(int maxK = 100, int B = 10, int driverID = 0, DateTime?startDate = null, DateTime?endDate = null) { double[] Wk = new double[maxK]; double[][] Wref_kb = new double[maxK][]; double[] Gap = new double[maxK]; double[] sd = new double[maxK]; KMeansClusterCollection[] clusterCollections = new KMeansClusterCollection[maxK]; // obtain dataset IEnumerable <Leg> legs = driverID == 0 ? await _legRepository.ListAsync() : await _legRepository.ListForDriverAsync(driverID); if (startDate == null) { startDate = DateTime.MinValue; } if (endDate == null) { endDate = DateTime.MaxValue; } legs = legs.Where(leg => leg.StartTime.CompareTo(startDate) >= 0 && leg.StartTime.CompareTo(endDate) < 0); double[][] dataset = GetDataset(legs); // first cluster the dataset varying K for (int k = 1; k <= maxK; k++) { KMeans kMeans = new KMeans(k) { // distance function for geographic coordinates Distance = new GeographicDistance() }; clusterCollections[k - 1] = kMeans.Learn(dataset); double[][][] clusterData = ClusterPoints(dataset, k, clusterCollections[k - 1]); // sum of pairwise distances Wk[k - 1] = ComputeWk(clusterData, clusterCollections[k - 1]); } // then generate the reference data sets double[] lowerBounds = new double[4]; double[] boxDimensions = new double[4]; for (int i = 0; i < 4; i++) { lowerBounds[i] = dataset.Select(l => l[i]).Min(); boxDimensions[i] = dataset.Select(l => l[i]).Max() - lowerBounds[i]; } CorrectLongitudeBounds(lowerBounds, boxDimensions, 1); CorrectLongitudeBounds(lowerBounds, boxDimensions, 3); Random random = new Random(); for (int k = 1; k <= maxK; k++) { Wref_kb[k - 1] = new double[B]; for (int c = 0; c < B; c++) { double[][] refDataset = new double[dataset.Length][]; for (int i = 0; i < refDataset.Length; i++) { double[] dataPoint = new double[4]; for (int j = 0; j < 4; j++) { dataPoint[j] = random.NextDouble() * boxDimensions[j] + lowerBounds[j]; if ((j == 1 || j == 3) && dataPoint[j] > 180) { dataPoint[j] -= 360; } } refDataset[i] = dataPoint; } // cluster reference dataset KMeans refKmeans = new KMeans(k); refKmeans.Distance = new GeographicDistance(); KMeansClusterCollection refClusters = refKmeans.Learn(refDataset); // points in each cluster double[][][] refClusterData = ClusterPoints(refDataset, k, refClusters); // compute pairwise distance sum for refDataset Wref_kb[k - 1][c] = ComputeWk(refClusterData, refClusters); } // compute gap statistic double l_avg = Wref_kb[k - 1].Select(x => Log(x)).Average(); Gap[k - 1] = l_avg - Log(Wk[k - 1]); sd[k - 1] = Sqrt(Wref_kb[k - 1].Select(x => (Log(x) - l_avg) * (Log(x) - l_avg)).Average()); // decide optimal k if (k > 1 && Gap[k - 2] >= Gap[k - 1] - sd[k - 1]) { ClusterCollection = clusterCollections[k - 2]; NumberOfClustersLastChanged = DateTime.Now; return; } } }
private static Tuple<double[][], double[][]> split(double[][] cluster, KMeans kmeans) { kmeans.Randomize(cluster); int[] idx = kmeans.Learn(cluster).Decide(cluster); List<double[]> a = new List<double[]>(); List<double[]> b = new List<double[]>(); for (int i = 0; i < idx.Length; i++) { if (idx[i] == 0) a.Add(cluster[i]); else b.Add(cluster[i]); } return Tuple.Create(a.ToArray(), b.ToArray()); }
public IActionResult Partition2(int partitionCount) { using (var db = new FusekiContext()) { var articles = db.Articles.Where(el => el.Published == true) .Include(el => el.Tags).Take(20).ToList(); //get a tag vector for each article. var allTags = new HashSet <string>(); //TODO: What happens if we remove all tags which only occur once. foreach (var article in articles) { foreach (var tag in article.Tags) { allTags.Add(tag.Name); } } var newAllTags = new HashSet <string>(); foreach (var t in allTags) { var relatedArticles = db.Articles.Where(el => el.Tags.Select(tag => tag.Name).Contains(t)); if (relatedArticles.Count() > 1) { newAllTags.Add(t); } } allTags = newAllTags; var allTagsOrdered = allTags.OrderBy(el => el); var obs = new List <List <double> >(); var dict = new Dictionary <string, object>(); foreach (var article in articles) { var articleTags = article.Tags.Select(el => el.Name); var vector = new List <double>(); foreach (var tag in allTagsOrdered) { if (articleTags.Contains(tag)) { vector.Add(1); } else { vector.Add(0); } } obs.Add(vector); } var vecvec = obs.Select(el => el.ToArray()).ToArray(); var kmeans = new KMeans(k: partitionCount); var clusters = kmeans.Learn(vecvec); dict["Kmeans Error"] = kmeans.Error; dict["dimensionality"] = kmeans.Dimension; dict["Iterations"] = kmeans.Iterations; dict["MaxIterations"] = kmeans.MaxIterations; dict["Tolerance"] = kmeans.Tolerance; int[] labels = clusters.Decide(vecvec); //labels is array[articleId] => partitionNumber var ii = 0; var psets = new List <PartitionSet <Article> >(); //this is totally fake. TODO: refactor these to be dumber - no need to have comparators etc. var dm = new DistanceMetrics <Article>((a, b) => Comparators.GetTagCommonality(a, b), (a, b) => Comparators.ArticleKeyLookup(a, b)); while (ii < partitionCount) { //TODO: is accord zero indexed? psets.Add(new PartitionSet <Article>(dm, ii)); ii++; } var index = 0; foreach (var l in labels) { var article = articles[index]; index++; psets[l].Add(article); } var partitiondata = new PartitionData <Article>(psets, dict); var model = new ArticlePartitionModel(partitiondata); return(View("ArticlePartitions", model)); } }
private void bClus_Click(object sender, RoutedEventArgs e) { int k = Int16.Parse(kKmeans.Text); int nB = classPoints[false].Count; int nR = classPoints[true].Count; if (nR + nB < 1) { textBlock.Text = "No dots."; return; } if (k < 1) { textBlock.Text = "Number of classes must be > 0."; return; } double[][] inputs = new double[nB + nR][]; int i = 0; foreach (System.Windows.Point p in classPoints[false]) { inputs[i++] = new double[] { p.X, p.Y }; } foreach (System.Windows.Point p in classPoints[true]) { inputs[i++] = new double[] { p.X, p.Y }; } KMeans kmeans = new KMeans(k: k); var clusters = kmeans.Learn(inputs); int[] labels = clusters.Decide(inputs); var centroids = clusters.Centroids; for (int j = 0; j < k; ++j) { Ellipse dot = new Ellipse(); dot.Width = 11; dot.Height = 11; dot.StrokeThickness = 2; dot.Fill = blackBrush; Canvas.SetTop(dot, centroids[j][1] - 5); Canvas.SetLeft(dot, centroids[j][0] - 5); cvsML.Children.Add(dot); double max = 0; for (int z = 0; z < labels.Length; ++z) { if (labels[z] == j) { double d = Math.Sqrt(Math.Pow(centroids[j][0] - inputs[z][0], 2) + Math.Pow(centroids[j][1] - inputs[z][1], 2)); if (d > max) { max = d; } } } Ellipse circle = new Ellipse(); circle.Width = 2 * max + 10; circle.Height = 2 * max + 10; circle.StrokeThickness = 2; circle.Stroke = blackBrush; Canvas.SetTop(circle, centroids[j][1] - max - 5); Canvas.SetLeft(circle, centroids[j][0] - max - 5); cvsML.Children.Add(circle); } }
// GET: DataAnalysis/KmeansAnalysis/id public async Task <IActionResult> KmeansAnalysis(int?id, int?numOfClusters) { if (id == null) { return(NotFound()); } var dataAnalysis = await _context.FilesInformation.FindAsync(id); if (dataAnalysis == null) { return(NotFound()); } string path = await _context.FilesInformation.Where(m => m.Id == id).Select(d => d.Path).FirstOrDefaultAsync(); CsvReader reader = new CsvReader(_appEnvironment.WebRootPath + path, hasHeaders: true); DataTable dataTable = reader.ToTable(); var headers = reader.GetFieldHeaders(); double[][] arrayOfData = dataTable.AsEnumerable().Select(x => new[] { Convert.ToDouble(x[headers[0]]), Convert.ToDouble(x[headers[1]]), Convert.ToDouble(x[headers[2]]) }).ToArray(); int numOfClustersOnPost = numOfClusters ?? default(int); if (numOfClusters == null) { numOfClustersOnPost = 3; } // Create a new K-Means algorithm KMeans kmeans = new KMeans(k: numOfClustersOnPost); // Compute and retrieve the data centroids var clusters = kmeans.Learn(arrayOfData); // Use the centroids to parition all the data int[] clusterId = clusters.Decide(arrayOfData); ViewBag.data = arrayOfData; ViewBag.columns = 3; ViewBag.rows = arrayOfData.Length; List <double> field1 = new List <double>(); List <double> field2 = new List <double>(); List <double> field3 = new List <double>(); for (int i = 0; i < ViewBag.data.Length; i++) { for (int j = 0; j < ViewBag.columns; j += 3) { field1.Add(ViewBag.data[i][j]); field2.Add(ViewBag.data[i][j + 1]); field3.Add(ViewBag.data[i][j + 2]); } } ViewBag.field1 = field1; ViewBag.field2 = field2; ViewBag.field3 = field3; ViewBag.nameField1 = headers[0]; ViewBag.nameField2 = headers[1]; ViewBag.nameField3 = headers[2]; ViewBag.clusters = clusterId; return(View()); }
/// <summary> /// Initializes the Gaussian Mixture Models using K-Means /// parameters as an initial parameter guess. /// </summary> /// private void btnInitialize_Click(object sender, EventArgs e) { // Creates and computes a new // K-Means clustering algorithm: kmeans = new KMeans(k); KMeansClusterCollection clustering = kmeans.Learn(observations); // Classify all instances in mixture data int[] classifications = clustering.Decide(observations); // Draw the classifications updateGraph(classifications); }
/** * Get related post for each post * Use k-means cluster algorithm */ public void PostetsRelatedAi() { // Get all posts from db var posts = (from p in db.Posts where p.Content.Length > 50 // Avoid uneccesary outliers select p).ToList(); // Create Array of all posts content string[] documents = (from p in db.Posts where p.Content.Length > 50 // Avoid uneccesary outliers select p.Content).ToArray(); ///Apply TF*IDF on the documents and get the resulting vectors. double[][] inputs = TFIDFEX.TFIDF.Transform(documents); inputs = TFIDFEX.TFIDF.Normalize(inputs); // Create a new K-Means algorithm with Posts/2 clusters (create couples) KMeans kmeans = new KMeans(Convert.ToInt32(posts.Count() / 2)); // Compute the algorithm, retrieving an integer array // containing the labels for each of the observations KMeansClusterCollection clusters = kmeans.Learn(inputs); int[] labels = clusters.Decide(inputs); // Create more handy list of clusters and their vectors var clustersList = new List <List <int> >(); for (int j = 0; j < Convert.ToInt32(posts.Count() / 2); j++) { clustersList.Add(labels.Select((s, i) => new { i, s }) .Where(t => t.s == j) .Select(t => t.i) .ToList()); } // Adjust all posts and thier related according to clustering results foreach (var clusetr in clustersList) { // Handle clusters with 2 and more vectors if (clusetr.Count() >= 2) { for (int i = 1; i < clusetr.Count(); i++) { // Attach each post in the cluster to it's neighbor posts[clusetr[i - 1]].relatedPost = posts[clusetr[i]].Title; } // Attach the last post to the first one in the list posts[clusetr.Last()].relatedPost = posts[clusetr.First()].Title; } // Handle clusters with only one vector else if (clusetr.Count() > 0) { // In case matching not found posts[clusetr.First()].relatedPost = null; } } // Update Changes in DB foreach (var p in posts) { db.Entry(p).State = EntityState.Modified; } db.SaveChanges(); }
public void learn_test_mixed() { #region doc_learn_mixed Accord.Math.Random.Generator.Seed = 0; // Declare some mixed discrete and continuous observations double[][] observations = { // (categorical) (discrete) (continuous) new double[] { 1, -1, -2.2 }, new double[] { 1, -6, -5.5 }, new double[] { 2, 1, 1.1 }, new double[] { 2, 2, 1.2 }, new double[] { 2, 2, 2.6 }, new double[] { 3, 2, 1.4 }, new double[] { 3, 4, 5.2 }, new double[] { 1, 6, 5.1 }, new double[] { 1, 6, 5.9 }, }; // Create a new codification algorithm to convert // the mixed variables above into all continuous: var codification = new Codification <double>() { CodificationVariable.Categorical, CodificationVariable.Discrete, CodificationVariable.Continuous }; // Learn the codification from observations var model = codification.Learn(observations); // Transform the mixed observations into only continuous: double[][] newObservations = model.ToDouble().Transform(observations); // (newObservations will be equivalent to) double[][] expected = { // (one hot) (discrete) (continuous) new double[] { 1, 0, 0, -1, -2.2 }, new double[] { 1, 0, 0, -6, -5.5 }, new double[] { 0, 1, 0, 1, 1.1 }, new double[] { 0, 1, 0, 2, 1.2 }, new double[] { 0, 1, 0, 2, 2.6 }, new double[] { 0, 0, 1, 2, 1.4 }, new double[] { 0, 0, 1, 4, 5.2 }, new double[] { 1, 0, 0, 6, 5.1 }, new double[] { 1, 0, 0, 6, 5.9 }, }; // Create a new K-Means algorithm KMeans kmeans = new KMeans(k: 3); // Compute and retrieve the data centroids var clusters = kmeans.Learn(observations); // Use the centroids to parition all the data int[] labels = clusters.Decide(observations); #endregion Assert.IsTrue(expected.IsEqual(newObservations, 1e-8)); Assert.AreEqual(3, codification.NumberOfInputs); Assert.AreEqual(5, codification.NumberOfOutputs); Assert.AreEqual(3, codification.Columns.Count); Assert.AreEqual("0", codification.Columns[0].ColumnName); Assert.AreEqual(3, codification.Columns[0].NumberOfSymbols); Assert.AreEqual(1, codification.Columns[0].NumberOfInputs); Assert.AreEqual(1, codification.Columns[0].NumberOfOutputs); Assert.AreEqual(3, codification.Columns[0].NumberOfClasses); Assert.AreEqual(CodificationVariable.Categorical, codification.Columns[0].VariableType); Assert.AreEqual("1", codification.Columns[1].ColumnName); Assert.AreEqual(1, codification.Columns[1].NumberOfSymbols); Assert.AreEqual(1, codification.Columns[1].NumberOfInputs); Assert.AreEqual(1, codification.Columns[1].NumberOfOutputs); Assert.AreEqual(1, codification.Columns[1].NumberOfClasses); Assert.AreEqual(CodificationVariable.Discrete, codification.Columns[1].VariableType); Assert.AreEqual("2", codification.Columns[2].ColumnName); Assert.AreEqual(1, codification.Columns[2].NumberOfSymbols); Assert.AreEqual(1, codification.Columns[2].NumberOfInputs); Assert.AreEqual(1, codification.Columns[2].NumberOfOutputs); Assert.AreEqual(1, codification.Columns[2].NumberOfClasses); Assert.AreEqual(CodificationVariable.Continuous, codification.Columns[2].VariableType); Assert.AreEqual(labels[0], labels[2]); Assert.AreEqual(labels[0], labels[3]); Assert.AreEqual(labels[0], labels[4]); Assert.AreEqual(labels[0], labels[5]); Assert.AreEqual(labels[6], labels[7]); Assert.AreEqual(labels[6], labels[8]); Assert.AreNotEqual(labels[0], labels[1]); Assert.AreNotEqual(labels[0], labels[6]); int[] labels2 = kmeans.Clusters.Decide(observations); Assert.IsTrue(labels.IsEqual(labels2)); var c = new KMeansClusterCollection.KMeansCluster[clusters.Count]; int i = 0; foreach (var cluster in clusters) { c[i++] = cluster; } for (i = 0; i < c.Length; i++) { Assert.AreSame(c[i], clusters[i]); } }
public (List <string> classes, KMeans kmeans, OneVsAllSupportVectorMachine svm) FinishLearning( int vectorLength, CancellationToken cancellationToken) { // count classes List <string> classes = new List <string>(this.features.Select(x => x.truth).ToLookup(x => x).Select(x => x.Key)); if (classes.Count < 2) { throw new ArgumentException(); } classes.Sort(); // count vectors int numberOfVectors = this.features.Sum(x => x.features.Count); // copy vectors Dictionary <IVector <float>, float> vectors = new Dictionary <IVector <float>, float>(numberOfVectors); for (int i = 0, ii = this.features.Count; i < ii; i++) { FeatureDetectors.Features f = this.features[i].features; for (int j = 0, jj = f.Count, len = f.Length, off = 0; j < jj; j++, off += len) { ////DenseVectorF vector = new DenseVectorF(len, f.X, off); SparseVectorF vector = SparseVectorF.FromDense(len, f.X, off); vectors[vector] = vectors.TryGetValue(vector, out float weight) ? weight + 1.0f : 1.0f; } } cancellationToken.ThrowIfCancellationRequested(); // learn k-means KMeans kmeans = KMeans.Learn( vectorLength, KMeansSeeding.Random, 2, default(EuclideanDistance), vectors.Keys.ToList(), vectors.Values.ToList(), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); // learn svm Dictionary <string, int> classesLookup = classes.ToDictionary((x, i) => x, (x, i) => i); SequentualMinimalOptimization smo = new SequentualMinimalOptimization(new ChiSquare()) { Algorithm = SMOAlgorithm.LibSVM, Tolerance = 0.01f, }; List <float[]> svmx = new List <float[]>(this.features.Count); List <int> svmy = new List <int>(this.features.Count); for (int i = 0, ii = this.features.Count; i < ii; i++) { (FeatureDetectors.Features features, string truth) = this.features[i]; svmx.Add(PointsOfInterestClassifier.PrepareVector(kmeans, features, cancellationToken)); svmy.Add(classesLookup[truth]); } cancellationToken.ThrowIfCancellationRequested(); OneVsAllSupportVectorMachine svm = OneVsAllSupportVectorMachine.Learn( smo, classes.Count, svmx, svmy, null, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); return(classes, kmeans, svm); }
// GET: DataAnalysis/CombinedAnalysis/id public async Task <IActionResult> CombinedAnalysis(int?id, int?numOfClusters) { if (id == null) { return(NotFound()); } var dataAnalysis = await _context.FilesInformation.FindAsync(id); if (dataAnalysis == null) { return(NotFound()); } string path = await _context.FilesInformation.Where(m => m.Id == id).Select(d => d.Path).FirstOrDefaultAsync(); CsvReader reader = new CsvReader(_appEnvironment.WebRootPath + path, hasHeaders: true); double[][] actual = reader.ToJagged(); var pcaTool = new KernelPrincipalComponentAnalysis(); pcaTool.Learn(actual); pcaTool.NumberOfOutputs = 3; var outputMatrix = pcaTool.Transform(actual); int numOfClustersOnPost = numOfClusters ?? default(int); if (numOfClusters == null) { numOfClustersOnPost = 3; } KMeans kmeans = new KMeans(k: numOfClustersOnPost); var clusters = kmeans.Learn(outputMatrix); int[] clusterId = clusters.Decide(outputMatrix); ViewBag.columns = pcaTool.NumberOfOutputs; ViewBag.rows = outputMatrix.Length; List <double> PC1 = new List <double>(); List <double> PC2 = new List <double>(); List <double> PC3 = new List <double>(); for (int i = 0; i < outputMatrix.Length; i++) { for (int j = 0; j < ViewBag.columns; j += 3) { outputMatrix[i][j] = Math.Round(outputMatrix[i][j], 3); outputMatrix[i][j + 1] = Math.Round(outputMatrix[i][j + 1], 3); outputMatrix[i][j + 2] = Math.Round(outputMatrix[i][j + 2], 3); PC1.Add(outputMatrix[i][j]); PC2.Add(outputMatrix[i][j + 1]); PC3.Add(outputMatrix[i][j + 2]); } } ViewBag.data = outputMatrix; ViewBag.pc1 = PC1; ViewBag.pc2 = PC2; ViewBag.pc3 = PC3; ViewBag.clusters = clusterId; return(View()); }
public void objectClustering() { int applyClusterNum = clusterNum; if (applyClusterNum > objectidList.Count) { applyClusterNum = objectidList.Count; } var kmeans = new KMeans(k: applyClusterNum); double[][] points = new double[objectidList.Count][]; for (int i = 0; i < objectidList.Count; i++) { int id = objectidList[i]; points[i] = ObjList[idxbyObjid[id]].getStartingPoint(); } KMeansClusterCollection clusters = kmeans.Learn(points); int[] output = clusters.Decide(points); setStartingGroup(); int maxClusterLength = objectidList.Count / applyClusterNum; for (int i = 0; i < objectidList.Count; i++) { int id = objectidList[i]; //startingGroup[output[i]].Add(id); if (startingGroup[output[i]].idList.Count < maxClusterLength) { startingGroup[output[i]].Add(id); } else { for (int j = output[i]; j < applyClusterNum + output[i]; j++) { if (startingGroup[(j + 1) % applyClusterNum].idList.Count < maxClusterLength) { startingGroup[(j + 1) % applyClusterNum].Add(id); break; } } } //^ } //sort int maxFrameLength = 0; for (int k = 0; k < startingGroup.Count; k++) { startingGroup[k].sort(ref ObjList, ref idxbyObjid); int curFrameLength = startingGroup[k].getFrameLength(); if (maxFrameLength < curFrameLength) { maxFrameLength = curFrameLength; } } //set maxFrmae //MessageBox.Show(overlayFrameNum.ToString()); outputFrameNum = trackingBar.Maximum = maxFrameLength - 1; if (videoInfo3Flag == true) { strVideoInfo3 += "\nresult Frame: " + outputFrameNum; } videoInfo3Flag = false; labelVideoInfo3.Text = strVideoInfo3; labelProgress.Text = "Detection 100%\nTracking 100%\nOverlay 100%"; int min = outputFrameNum / analysisFPS / 60; int sec = outputFrameNum / analysisFPS % 60; labelEndTime.Text = min.ToString("00") + ":" + sec.ToString("00"); }
public void dayWorkSchedule(DateTime date) { Func <WorkSchedule, bool> predicat = (w => w.workSchedule_date == date); List <WorkSchedule> workSchedules = selectWorkSchedule(predicat); List <Distributors> alldistributors = new List <Distributors>(); List <Distributors> ezerList = new List <Distributors>(); foreach (WorkSchedule item in workSchedules) { ezerList = selectDistributors(d => d.distributors_id == item.distributor_id); if (ezerList.Count != 1) { throw new Exception("שגיאה בחיפוש אחרי מחלק זה"); } alldistributors.Add(ezerList[0]); } List <Recipients> allrecipients = recipientsPackageByDay(date); double[][] Coordinates = new double[allrecipients.Count][]; int i = 0; foreach (Recipients item in allrecipients) { Coordinates[i] = getLatLongFromAddress(item.recipients_address); i++; } // Create a new K-Means algorithm with 3 clusters KMeans kmeans = new KMeans(3); // Compute the algorithm, retrieving an integer array // containing the labels for each of the observations KMeansClusterCollection clusters = kmeans.Learn(Coordinates); // As a result, the first two observations should belong to the // same cluster (thus having the same label). The same should // happen to the next four observations and to the last three. int[] labels = clusters.Decide(Coordinates); List <Recipients> group0 = new List <Recipients>(); List <Recipients> group1 = new List <Recipients>(); List <Recipients> group2 = new List <Recipients>(); for (int k = 0; k < labels.Length; k++) { if (labels[k] == 0) { group0.Add(allrecipients[k]); } if (labels[k] == 1) { group1.Add(allrecipients[k]); } if (labels[k] == 2) { group2.Add(allrecipients[k]); } } double lat = 0; double lon = 0; double[] d0 = new double[2]; double[] d1 = new double[2]; double[] d2 = new double[2]; foreach (var item in group0) { d0 = getLatLongFromAddress(item.recipients_address); lat += d0[0]; lon += d0[1]; } d0[0] = lat / group0.Count; d0[1] = lon / group0.Count; lat = 0; lon = 0; foreach (var item in group1) { d1 = getLatLongFromAddress(item.recipients_address); lat += d1[0]; lon += d1[1]; } d1[0] = lat / group1.Count; d1[1] = lon / group1.Count; lat = 0; lon = 0; foreach (var item in group2) { d2 = getLatLongFromAddress(item.recipients_address); lat += d2[0]; lon += d2[1]; } d2[0] = lat / group2.Count; d2[1] = lon / group2.Count; // double[] d0 = getLatLongFromAddress(group0[0].recipients_address); // double[] d1 = getLatLongFromAddress(group1[0].recipients_address); // double[] d2 = getLatLongFromAddress(group2[0].recipients_address); double[,] distance = new double[3, 3]; for (i = 0; i < 3; i++) { double[] d3 = getLatLongFromAddress(alldistributors[i].distributors_address); for (int j = 0; j < 3; j++) { if (j == 0) { distance[i, j] = dalImp.addressCalculations.calculateDistance(d0, d3); } if (j == 1) { distance[i, j] = dalImp.addressCalculations.calculateDistance(d1, d3); } if (j == 2) { distance[i, j] = dalImp.addressCalculations.calculateDistance(d2, d3); } } } int [,] minIndex = new int[3, 3]; for (i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { minIndex[i, j] = findMinDist(distance[i, 0], distance[i, 1], distance[i, 2], j); } } if ((minIndex[0, 0] != minIndex[2, 0]) && (minIndex[0, 0] != minIndex[1, 0]) && (minIndex[2, 0] != minIndex[1, 0])) { if (minIndex[0, 0] == 0) { UpdateWorkSchedule(new WorkSchedule(alldistributors[0].distributors_id, date, group0)); if (minIndex[1, 0] == 1) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group2)); } else if (minIndex[1, 0] == 2) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group2)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group1)); } } else if (minIndex[0, 0] == 1) { UpdateWorkSchedule(new WorkSchedule(alldistributors[0].distributors_id, date, group1)); if (minIndex[1, 0] == 0) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group0)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group2)); } else if (minIndex[1, 0] == 2) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group2)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group0)); } } else if (minIndex[0, 0] == 2) { UpdateWorkSchedule(new WorkSchedule(alldistributors[0].distributors_id, date, group2)); if (minIndex[1, 0] == 0) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group0)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group1)); } else if (minIndex[1, 0] == 1) { UpdateWorkSchedule(new WorkSchedule(alldistributors[1].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[2].distributors_id, date, group0)); } } } else { if ((minIndex[0, 0] == minIndex[2, 0]) && (minIndex[0, 0] == minIndex[1, 0]) && (minIndex[2, 0] == minIndex[1, 0])) { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[0, 0]].distributors_id, date, group0)); if ((minIndex[1, 1] == minIndex[2, 1])) { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[1, 1]].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[2, 2]].distributors_id, date, group2)); } else { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[1, 1]].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[2, 1]].distributors_id, date, group2)); } } else { int place; if (minIndex[1, 0] == minIndex[2, 0]) { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[0, 0]].distributors_id, date, group0)); place = minIndex[1, 1] + minIndex[1, 1] % 3; UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[1, 0]].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[place].distributors_id, date, group2)); } else { if (minIndex[0, 0] == minIndex[2, 0]) { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[1, 0]].distributors_id, date, group1)); place = minIndex[0, 0] + minIndex[1, 0] % 3; UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[0, 0]].distributors_id, date, group1)); UpdateWorkSchedule(new WorkSchedule(alldistributors[place].distributors_id, date, group2)); } else { UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[2, 0]].distributors_id, date, group2)); place = minIndex[0, 0] + minIndex[2, 0] % 3; UpdateWorkSchedule(new WorkSchedule(alldistributors[minIndex[1, 1]].distributors_id, date, group0)); UpdateWorkSchedule(new WorkSchedule(alldistributors[place].distributors_id, date, group1)); } } } } }
public void learn_test() { #region doc_learn Accord.Math.Random.Generator.Seed = 0; // Declare some observations double[][] observations = { new double[] { -5, -2, -1 }, new double[] { -5, -5, -6 }, new double[] { 2, 1, 1 }, new double[] { 1, 1, 2 }, new double[] { 1, 2, 2 }, new double[] { 3, 1, 2 }, new double[] { 11, 5, 4 }, new double[] { 15, 5, 6 }, new double[] { 10, 5, 6 }, }; double[][] orig = observations.MemberwiseClone(); // Create a new K-Means algorithm with 3 clusters KMeans kmeans = new KMeans(3); // Compute the algorithm, retrieving an integer array // containing the labels for each of the observations KMeansClusterCollection clusters = kmeans.Learn(observations); // As a result, the first two observations should belong to the // same cluster (thus having the same label). The same should // happen to the next four observations and to the last three. int[] labels = clusters.Decide(observations); #endregion Assert.AreEqual(labels[0], labels[1]); Assert.AreEqual(labels[2], labels[3]); Assert.AreEqual(labels[2], labels[4]); Assert.AreEqual(labels[2], labels[5]); Assert.AreEqual(labels[6], labels[7]); Assert.AreEqual(labels[6], labels[8]); Assert.AreNotEqual(labels[0], labels[2]); Assert.AreNotEqual(labels[2], labels[6]); Assert.AreNotEqual(labels[0], labels[6]); int[] labels2 = kmeans.Clusters.Nearest(observations); Assert.IsTrue(labels.IsEqual(labels2)); // the data must not have changed! Assert.IsTrue(orig.IsEqual(observations)); var c = new KMeansClusterCollection.KMeansCluster[clusters.Count]; int i = 0; foreach (var cluster in clusters) { c[i++] = cluster; } for (i = 0; i < c.Length; i++) { Assert.AreSame(c[i], clusters[i]); } }
public void learn_test_weights() { #region doc_learn_weights Accord.Math.Random.Generator.Seed = 0; // A common desire when doing clustering is to attempt to find how to // weight the different components / columns of a dataset, giving them // different importances depending on the end goal of the clustering task. // Declare some observations double[][] observations = { new double[] { -5, -2, -1 }, new double[] { -5, -5, -6 }, new double[] { 2, 1, 1 }, new double[] { 1, 1, 2 }, new double[] { 1, 2, 2 }, new double[] { 3, 1, 2 }, new double[] { 11, 5, 4 }, new double[] { 15, 5, 6 }, new double[] { 10, 5, 6 }, }; // Create a new K-Means algorithm KMeans kmeans = new KMeans(k: 3) { // For example, let's say we would like to consider the importance of // the first column as 0.1, the second column as 0.7 and the third 0.9 Distance = new WeightedSquareEuclidean(new double[] { 0.1, 0.7, 1.1 }) }; // Compute and retrieve the data centroids var clusters = kmeans.Learn(observations); // Use the centroids to parition all the data int[] labels = clusters.Decide(observations); #endregion Assert.AreEqual(labels[0], labels[2]); Assert.AreEqual(labels[0], labels[2]); Assert.AreEqual(labels[0], labels[3]); Assert.AreEqual(labels[0], labels[4]); Assert.AreEqual(labels[0], labels[4]); Assert.AreEqual(labels[6], labels[7]); Assert.AreEqual(labels[6], labels[8]); Assert.AreNotEqual(labels[0], labels[1]); Assert.AreNotEqual(labels[2], labels[6]); Assert.AreNotEqual(labels[0], labels[6]); int[] labels2 = kmeans.Clusters.Decide(observations); Assert.IsTrue(labels.IsEqual(labels2)); var c = new KMeansClusterCollection.KMeansCluster[clusters.Count]; int i = 0; foreach (var cluster in clusters) { c[i++] = cluster; } for (i = 0; i < c.Length; i++) { Assert.AreSame(c[i], clusters[i]); } }
/// <summary> /// Computes the optimal number of clusters for the given observations. /// </summary> /// <param name="observationMatrix">The matrix of observations.</param> /// <param name="initialClusterCount">The initial number of clusters to start with.</param> /// <param name="isAgentTrajectoryClustering"> /// Dictates whether the clustering that is being performed is specific to /// two-dimensional agent trajectories (otherwise, distance calculations assume one-dimensional observation vectors). /// </param> /// <param name="isGreedySilhouetteCalculation"> /// Dictates whether optimal clustering is based on number of clusters that /// maximize silhouette score until the first decrease in score (true), or based on the silhouette score calculated for /// a range of clusters with the number of clusters resulting in the maximum score used as the optimal number of /// clusters (false). /// </param> /// <param name="clusterRange">The range of clusters values for which to compute the silhouette width (optional).</param> /// <returns>The cluster assignments and their proportions (as well as other K-Means stats).</returns> private static KMeans DetermineOptimalClusters(double[][] observationMatrix, int initialClusterCount, bool isAgentTrajectoryClustering, bool isGreedySilhouetteCalculation, int clusterRange = 0) { var clusterSilhouetteMap = new Dictionary <int, double>(); double maxSilhouetteWidth; // Initialize current silhouette width double curSilhouetteWidth = 0; // Set the initial cluster count var clusterCount = initialClusterCount; do { // Set max silhouette with the value on the previous loop iteration (since it was an improvement) maxSilhouetteWidth = curSilhouetteWidth; // Increment cluster count clusterCount++; // TODO: The below logic is in support of a work-around to an Accord.NET bug wherein // TODO: an internal random number generator sometimes generates out-of-bounds values // TODO: (i.e. a probability that is not between 0 and 1) // TODO: https://github.com/accord-net/framework/issues/259 // Create a new k-means instance with the specified number of clusters and uniform seeding var kmeans = new KMeans(clusterCount) { UseSeeding = Seeding.Uniform }; // Determine the resulting clusters var clusters = kmeans.Learn(observationMatrix); // Compute the silhouette width for the current number of clusters curSilhouetteWidth = ComputeSilhouetteWidth(clusters, observationMatrix, isAgentTrajectoryClustering); // If this is non-greedy silhouette calculation, record the silhouette width associated with // the current number of clusters if (isGreedySilhouetteCalculation == false) { clusterSilhouetteMap.Add(clusterCount, curSilhouetteWidth); } // Continue to increment number of clusters while there is a silhouette width improvement // (in the case of greedy silhouette calculation) or we have reached the max cluster range, // and we have not yet reached a number of clusters equivalent to the number of observations } while ((isGreedySilhouetteCalculation ? curSilhouetteWidth >= maxSilhouetteWidth : clusterCount < clusterRange) && clusterCount < observationMatrix.Length); // If this is non-greedy silhouette calculation, set the cluster count to the number of clusters // within the given range that results in the highest silhouette width (i.e. highest cluster validity) if (isGreedySilhouetteCalculation == false) { clusterCount = clusterSilhouetteMap.FirstOrDefault(csm => csm.Value == clusterSilhouetteMap.Values.Max()).Key; } // TODO: The below logic is in support of a work-around to an Accord.NET bug wherein // TODO: an internal random number generator sometimes generates out-of-bounds values // TODO: (i.e. a probability that is not between 0 and 1) // TODO: https://github.com/accord-net/framework/issues/259 // Rerun kmeans for the final cluster count with uniform seeding var optimalClustering = new KMeans(clusterCount) { UseSeeding = Seeding.Uniform }; // Determine cluster assignments optimalClustering.Learn(observationMatrix); return(optimalClustering); }
static void Main() { Accord.Math.Random.Generator.Seed = 1232; // Declare some observations double[][] observations = { new double[] { 291.5, 81.5 }, new double[] { 316, 87.5 }, new double[] { 337, 92.5 }, new double[] { 367, 87 }, new double[] { 363.5, 102 }, new double[] { 378, 105 }, new double[] { 411, 108.5 }, new double[] { 428.5, 116.5 }, new double[] { 465.5, 120 }, new double[] { 477, 111.5 }, new double[] { 448.5, 124.5 }, new double[] { 276, 126.5 }, new double[] { 503.5, 129 }, new double[] { 474, 126.5 }, new double[] { 485.5, 129 }, new double[] { 293.5, 134.5 }, new double[] { 313, 138.5 }, new double[] { 333.5, 146.5 }, new double[] { 355, 147.5 }, new double[] { 373.5, 152.5 }, new double[] { 393, 160 }, new double[] { 413.5, 161 }, new double[] { 98.5, 327.5 }, new double[] { 113, 338.5 }, new double[] { 130.5, 344.5 }, new double[] { 146.5, 347.5 }, new double[] { 171, 355 }, new double[] { 189, 364.5 }, new double[] { 223.5, 372 }, new double[] { 208, 374.5 }, new double[] { 237, 365.5 }, new double[] { 74, 379 }, new double[] { 232, 379.5 }, new double[] { 262, 385.5 }, new double[] { 244, 384 }, new double[] { 92, 388.5 }, new double[] { 112, 395 }, new double[] { 131, 405 }, new double[] { 152, 408.5 }, new double[] { 170.5, 415.5 }, new double[] { 485, 421.5 }, new double[] { 546, 421.5 }, new double[] { 742, 421.5 }, new double[] { 189, 425 }, new double[] { 506.5, 424.5 }, new double[] { 528.5, 424.5 }, new double[] { 583, 424.5 }, new double[] { 604, 424.5 }, new double[] { 624.5, 424.5 }, new double[] { 653, 430 }, new double[] { 695, 424.5 }, new double[] { 764.5, 424.5 }, new double[] { 721, 425 }, new double[] { 208, 428.5 }, new double[] { 242, 436.5 }, new double[] { 267, 445 }, new double[] { 286.5, 452 }, }; //observations.Add(new double[][] { (double)2.8, 3.3 }); // Create a new K-Means algorithm KMeans kmeans = new KMeans(k: 3); // Compute and retrieve the data centroids var clusters = kmeans.Learn(observations); // Use the centroids to parition all the data int[] labels = clusters.Decide(observations); Console.WriteLine("Hello World!"); // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public ActionResult Index() { User usrCon = (User)HttpContext.Session["user"]; if (usrCon != null) { Accord.Math.Random.Generator.Seed = 0; List <Product> boughtP = (from prd in db.Products join perord in db.ProductsPerOrder on prd.ProductId equals perord.ProductId join ord in db.Orders on perord.OrderId equals ord.OrderId join usr in db.Users on ord.UserId equals usr.UserId where ord.isOpen == false && usr.UserId == usrCon.UserId select prd).ToList(); if (boughtP.Count <= 5) { return(View(db.Products.ToList())); } Dictionary <double, double> countDic = new Dictionary <double, double> { { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 }, { 5, 0 } }; foreach (var p in boughtP) { countDic[p.ProductCategory.ProductCategoryID]++; } // Declare some observations double[][] observations = new double[boughtP.Count][]; for (int j = 0; j < boughtP.Count; j++) { observations[j] = new double[2]; } int i = 0, k = 0; foreach (var item in countDic) { for (int j = 0; j < countDic[i + 1]; j++) { observations[j + k][0] = item.Key; observations[j + k][1] = item.Value; } k = (int)countDic[i + 1] + k; i++; } // Create a new K-Means algorithm with 3 clusters KMeans kmeans = new KMeans(5); // Compute the algorithm, retrieving an integer array // containing the labels for each of the observations KMeansClusterCollection clusters = kmeans.Learn(observations); // As a result, the first two observations should belong to the // same cluster (thus having the same label). The same should // happen to the next four observations and to the last three. //int[] labels = clusters.Decide(/*observations);*/ int chosenCatId = (int)clusters.Clusters.SingleOrDefault(y => y.Proportion == clusters.Clusters.Max(x => x.Proportion)).Centroid[0]; return(View(db.Products.Where(x => x.ProductCategoryID == chosenCatId).ToList())); } return(View("~/Views/User/Login.cshtml")); }