TEAMModelOS/TEAMModelOS.Extension/HTEX.Test/Service/MLService.cs

using Microsoft.ML.Data;
using Microsoft.ML;

namespace HTEX.Test.Service
{
    public static class MLService
    {
     
        /// <summary>
        /// 
        /// </summary>
        /// <param name="datas">数据需要去掉0</param>
        /// <param name="numberOfClusters"></param>
        /// <returns></returns>
        public static List<ClusterData> KMeans(float[] datas, int numberOfClusters = 2)
        {
            List<DataPoint> data = new List<DataPoint>();
            foreach (var d in datas)
            {
                data.Add(new DataPoint { Feature = d });
            }

            // 定义数据视图  
            var mlContext = new MLContext();
            var dataView = mlContext.Data.LoadFromEnumerable(data);
            // 定义聚类管道  
            var pipeline = mlContext.Transforms.Concatenate("Features", new[] { "Feature" })
                                .Append(mlContext.Clustering.Trainers.KMeans(numberOfClusters: numberOfClusters)); // 假设我们想要将数据分成3个集群  
                                                                                                                   // 训练模型  
            var model = pipeline.Fit(dataView);

            // 转换数据以获取聚类结果  
            var predictions = model.Transform(dataView);

            // 提取聚类结果  
            var inMemoryCollection = mlContext.Data.CreateEnumerable<ClusterPrediction>(predictions, reuseRowObject: false);



            // 打印聚类结果  
            //var clusterSizes = new int[3]; // 假设有3个聚类  
            int index = 0;
            List<ClusterData> clusterDatas = new List<ClusterData>();
            foreach (var prediction in inMemoryCollection)
            {
                //Console.WriteLine($"Data point: {data[index].Feature}, Cluster: {prediction.ClusterId}");
                var clusterData = clusterDatas.Find(x => x.ClusterId.Equals(prediction.ClusterId));
                if (clusterData!=null)
                {
                    clusterData.count +=1;
                    clusterData.datas.Add(data[index].Feature);
                    clusterData.avg=clusterData.datas.Sum()*1.0F / clusterData.datas.Count();
                }
                else
                {
                    clusterDatas.Add(new ClusterData { avg=data[index].Feature, count=1, ClusterId=prediction.ClusterId, datas=new List<float> { data[index].Feature } });
                }
                index++;
                //计算每个聚类的数据点数量
                //clusterSizes[prediction.ClusterId-1]++;
            }
            // 预测聚类

            // 确定最密集的部分  
            // 这通常需要对聚类结果进行分析，比如计算每个聚类的平均距离、大小等  
            // 在这里，你可以通过比较不同聚类的数据点数量或计算聚类中心周围的密度来估计哪个是最密集的  




            // 找出最大的聚类  
            //  var maxClusterIndex = clusterSizes.ToList().IndexOf(clusterSizes.Max());
            //Console.WriteLine($"The densest cluster is cluster {maxClusterIndex} with {clusterSizes[maxClusterIndex]} data points.");

            // 你还可以进一步分析聚类的特性，比如找出聚类中心、计算聚类内的方差等  

            return clusterDatas;
        }
       /// <summary>
       /// 
       /// </summary>
       /// <param name="datas"></param>
       /// <param name="numberOfClusters"></param>
       /// <param name="dropPercent">最大平均数的聚类与数量最多的聚类数量的落差小于30% 则以更高的为准</param>
       /// <returns></returns>
        public static (ClusterData clusterData, List<ClusterData> clusterDatas) GetNormalCluster (float[] datas, int numberOfClusters = 2,double dropPercent=0.3)
        {
            List<ClusterData> clusterDatas = KMeans(datas, numberOfClusters);
            clusterDatas=clusterDatas.OrderByDescending(dr => dr.count).ToList();
            ClusterData clusterData = FindSatisfactoryRecord(clusterDatas, 0, dropPercent);
            return (clusterData, clusterDatas);
        }

        static ClusterData FindSatisfactoryRecord(List<ClusterData> data, int currentIndex,double dropPercent)
        {        // 如果当前索引小于0，说明已经到达列表开头，返回null
            if (currentIndex < 0) { return null; }

            // 获取当前数据
            ClusterData current = data.ElementAt(currentIndex);
            if (currentIndex+1>=data.Count())
            {
                return current;
            }
            else
            {
                ClusterData next = data.ElementAt(currentIndex +1);        // 检查平均值和人数差是否满足条件
                if (current.avg > next.avg)
                {
                    return current;
                }
                else
                {
                    var d = (current.count- next.count)*1.0/current.count;
                    if (d>=dropPercent)
                    {
                        return current;
                    }
                    else
                    { // 递归调用，继续向前比较
                        return FindSatisfactoryRecord(data, currentIndex + 1, dropPercent);
                    }
                }
            }
        }
    }
    // 定义数据模型  
    public class DataPoint
    {
        public float Feature { get; set; }
    }
    // 聚类预测类  
    public class ClusterPrediction
    {
        [ColumnName("PredictedLabel")]
        public uint ClusterId;

        // 你可以添加其他预测列，比如距离聚类中心的距离等  
    }
    public class ClusterData
    {
        public List<float> datas = new List<float>();
        public uint ClusterId { get; set; }
        public int count { get; set; }
        public float avg { get; set; }
    }
}