精华内容
下载资源
问答
  • 模糊聚类 关键词:模糊聚类,半监督 介绍 本开源项目为模糊聚类算法python代码,主要算法包括: FCM(模糊C均值算法) MEC(极大熵模糊聚类算法) 核模糊聚类算法 SFCM(半监督模糊聚类算法) eSFCM(基于信息熵...
  • 模糊聚类实例

    2019-04-03 09:38:38
    模糊传递闭包法的示例,通过这一例子,可以理解传递闭包法
  • 模糊聚类matlab程序

    2019-01-25 15:07:20
    积分最低,模糊聚类matlab程序,里面有相关系数法聚类,欧几里得法等聚类方法
  • 模糊聚类分析及matlab程序实现 采用模糊数学语言对按一定的要求进行描述和分类的数学方法称为模糊聚类分析聚类分析主要经过标定和聚类两步骤1 1 标定建立模糊相似矩阵 城市居民食品零售价格第t时刻第i种食品的零售价...
  • 该资源包括两部分代码,都是python实现,使用两种方式实现了模糊聚类,使用的数据集也在压缩包内,配置好环境可直接运行。
  • 模糊聚类分析matlab

    2018-02-07 00:25:57
    模糊聚类分析实验报告+matlab代码 模糊聚类分析实验报告+matlab代码
  • 运用python代码进行模糊聚类步骤如下:建立数据矩阵;数据标准化;建立模糊相似矩阵;改造相似关系为等价关系;确定分类数
  • 模糊聚类算法分析及应用.pdf
  • 实验结果显示与使用单一类型差异图的聚类方法相比,本方法由于采用了图像融合的策略而增强了鲁棒性,且由于采用了核模糊聚类,进一步提高了变化检测精度.此外由于使用了特征提取的技术,本方法具有一定的抗噪性能.
  • GG模糊聚类算法.rar
  • 避免先前基于例子的音频检索要按照监督机制训练不同类别的复杂的音频模板,直接从原始音频流中提取压缩域特征,使用时空约束机制进行压缩域特征的模糊聚类,用聚类结果的质心来表征整个音频例子,基于聚类质心完成...
  • 运用matlab进行模糊聚类分析步骤如下:建立数据矩阵;数据标准化;建立模糊相似矩阵;改造相似关系为等价关系;确定分类数
  • 通过matlab对fcm模糊聚类分析进行了代码实现。代码简单适合初学者。
  • 虽然模糊聚类算法被广泛用于对重叠和模糊的对象进行分组,但它们不能直接应用于时间序列分割,因为聚类需要在时间上是连续的。 本文提出了一种用于同时识别局部概率主成分分析 (PPCA) 模型的聚类算法,该模型用于...
  • 针对基于高斯混合模型的模糊聚类算法对噪声和异常值敏感的问题,利用包含邻域关系的先验概率与Student’s-T分布构建基于空间约束的混合模型,并结合熵规则化项定义模糊聚类目标函数。Student’s-T分布具有重尾的特点...
  • 运用MATLAB做模糊聚类系谱图,该方法简便,动态谱系图具有多个分类系数与多种分析,可以按需选择
  • matlab代码+GUI设计+论文;版本是MATLAB2017a。期末做的课程设计,有七种模糊聚类图像分割的比较及分析,HCM、FCM、FCMS、FCMS1、FCMS2、EnFCM、FLICM。
  • 对TBC特征矩阵进行平移极差变换,利用指数切比雪夫距离法构建了模糊相似矩阵,采用模糊聚类中的传递闭包法构建进化树。该方法不需要多序列比对,计算简单。对两组基因组序列构建进化树,实验结果验证了该方法的有效...
  • 聚类分析中
  • FCM模糊聚类matlab代码

    2018-07-22 17:32:55
    FCM模糊聚类matlab代码,function [C, dist, J] = fcm(X, k, b)
  • 动态模糊聚类算法

    2016-12-15 15:16:24
    本资源通过matlab编写的动态模糊聚类算法,并且包含形成模糊矩阵的不同方法,最后形成直观的动态聚类图,结果十分直观,对理解模糊算法及动态聚类有相当大的帮助。
  • 针对现有集成方法在处理模糊聚类时存在的不足,提出一种基于证据理论的模糊聚类集成方法.以各聚类成员作为证据元,以样本点间的类别关系作为焦元,通过证据积累构造互相关矩阵.考虑到模糊聚类对于各样本点的聚类有效性,...
  • 计算隶属度矩阵和聚类中心,使得目标函数最小%算法步骤:初始化聚类中心,然后计算每一个样本对于每一类的隶属度,最终得到隶属度矩阵mu(i
  • 为了在聚类数不确定的情况下实现聚类分析,通过借鉴生物免疫系统中的克隆选择原理并结合聚类有效性分析,提出一种免疫模糊动态聚类算法。本算法不但可以根据数据自动确定聚类类目及中心位置,而且克服了传统聚类算法...
  • 模糊聚类的学位论文,比较详细,从原理到案例介绍这种算法的思想
  • 模糊聚类

    千次阅读 2019-11-04 10:35:09
    基本概念: 聚类分析是多元统计分析的一种,也是无监督...硬聚类把每个待识别的对象严格的划分某类中,具有非此即彼的性质,而模糊聚类建立了样本对类别的不确定描述,更能客观的反应客观世界,从而成为聚类分析的...

    基本概念:

    聚类分析是多元统计分析的一种,也是无监督模式识别的一个重要分支,在模式分类 图像处理和模糊规则处理等众多领域中获得最广泛的应用。它把一个没有类别标记的样本按照某种准则划分为若干子集,使相似的样本尽可能归于一类,而把不相似的样本划分到不同的类中。硬聚类把每个待识别的对象严格的划分某类中,具有非此即彼的性质,而模糊聚类建立了样本对类别的不确定描述,更能客观的反应客观世界,从而成为聚类分析的主流。模糊聚类算法是一种基于函数最优方法的聚类算法,使用微积分计算技术求最优代价函数,在基于概率算法的聚类方法中将使用概率密度函数,为此要假定合适的模型,模糊聚类算法的向量可以同时属于多个聚类,从而摆脱上述问题。

    模糊聚类分析算法大致可分为三类

    (1)分类数不定,根据不同要求对事物进行动态聚类,此类方法是基于模糊等价矩阵聚类的,称为模糊等价矩阵动态聚类分析法。

    (2)分类数给定,寻找出对事物的最佳分析方案,此类方法是基于目标函数聚类的,称为模糊C均值聚类。

    (3)在摄动有意义的情况下,根据模糊相似矩阵聚类,此类方法称为基于摄动的模糊聚类分析法

    本次仅介绍模糊C均值聚类。

    隶属度概念:

    模糊聚类算法是一种基于划分的聚类算法,它的思想就是使得被划分到同一簇的对象之间相似度最大,而不同簇之间的相似度最小。模糊聚类(FCM)对数据进行模糊划分,使用隶属度表示一个样本属于某一类的程度。

    隶属度函数是表示一个对象x 隶属于集合A 的程度的函数,通常记做μA(x),其自变量范围是所有可能属于集合A 的对象(即集合A 所在空间中的所有点),取值范围是[0,1],即0<=μA(x),μA(x)<=1。μA(x)=1 表示x 完全隶属于集合A,相当于传统集合概念上的x∈A。一个定义在空间X={x}上的隶属度函数就定义了一个模糊集合A,或者叫定义在论域X={x}上的模糊子集A’。对于有限个对象x1,x2,……,xn 模糊集合A’可以表示为:

    在聚类的问题中,可以把聚类生成的簇看成模糊集合,因此,每个样本点隶属于簇的隶属度就是[0,1]区间里面的值。

    模糊C均值聚类

    模糊c均值聚类融合了模糊理论的精髓。相较于k-means的硬聚类,模糊c提供了更加灵活的聚类结果。因为大部分情况下,数据集中的对象不能划分成为明显分离的簇,指派一个对象到一个特定的簇有些生硬,也可能会出错。故,对每个对象和每个簇赋予一个权值,指明对象属于该簇的程度。当然,基于概率的方法也可以给出这样的权值,但是有时候我们很难确定一个合适的统计模型,因此使用具有自然地、非概率特性的模糊c均值就是一个比较好的选择。

    简单地说,就是要最小化目标函数Jm:(在一些资料中也定义为SSE即误差的平方和)
    在这里插入图片描述
    其中m是聚类的簇数;i,j是类标号;u_i_j表示样本x_i属于j类的隶属度。i表示第i个样本,x是具有d维特征的一个样本。c_j是j簇的中心,也具有d维度。||*||可以是任意表示距离的度量。
    模糊c是一个不断迭代计算隶属度u_i_j和簇中心c_j的过程,直到他们达到最优。
    在这里插入图片描述
    注:对于单个样本x_i,它对于每个簇的隶属度之和为1。

    迭代的终止条件为:
    在这里插入图片描述
    其中k是迭代步数,是误差阈值。上式含义是,继续迭代下去,隶属程度也不会发生较大的变化。即认为隶属度不变了,已经达到比较优(局部最优或全局最优)状态了。该过程收敛于目标Jm的局部最小值或鞍点。

    抛开复杂的算式,这个算法的意思就是:给每个样本赋予属于每个簇的隶属度函数。通过隶属度值大小来将样本归类。

    模糊聚类算法步骤:

    1、初始化

    通常采用随机初始化。即权值随机地选取。簇数需要人为选定。

    2、计算质心

    FCM中的质心有别于传统质心的地方在于,它是以隶属度为权重做一个加权平均。

    3、更新模糊伪划分

    即更新权重(隶属度)。简单地说,如果x越靠近质心c,则隶属度越高,反之越低。

    数据样本:

    杯子数据

    数据量1500(条)
    数据属性(影响变量)5(种)
    属性1杯子高度(厘米)
    属性2杯口直径(厘米)
    属性3杯口周长(厘米)
    属性4杯子底部直径(厘米)
    属性5杯子容积(立方厘米)

    在这里插入图片描述

    代码:

    #include "stdio.h"
    #include "stdlib.h"
    #include "time.h"
    #include "math.h"
    #include "vector"
    using namespace std;
    
    
    #define alpha 0.5   //分裂比
    #define dimNum 3   //维数为3
    #define cNum 10  //初始类数
    #define expectNum 10  //预期成类数
    #define minNum 3     //小于此数则不能成类
    #define splitVar 1.2  //大于此数分裂
    #define connectVar 0.3  //小于此数合并
    #define connectNum 2   //每次迭代允许合并的最大数
    #define iterNum 30  //迭代次数为30
    
    
    
    
    typedef vector<double> doubleVector;
    typedef vector<doubleVector> clusterVector;
    
    
    void ISODATA(vector<doubleVector> srcInf);  //开始引擎
    vector<doubleVector> getInf();  //获取文件数据
    int getClusterNum(vector<doubleVector> mCenter, doubleVector srcInf); //归类
    double getEUCdis(doubleVector t1, doubleVector t2);  //计算欧式距离
    doubleVector get_wMean(clusterVector cluster);  //计算均值向量
    doubleVector averageDist(doubleVector mCenter, clusterVector cluster); //计算Wi中所有样本距其相应聚类中心的平均距离
    doubleVector allAvgDist(vector<doubleVector> avgDis); //计算所以样本距其相应的聚类中心的平均值
    doubleVector getDeviation(doubleVector mCenter, clusterVector cluster); //计算没一聚类的标准偏差
    double getMaxDev(doubleVector Dev);  //获取最大标准偏差
    doubleVector clusterSplit(doubleVector wMean, double sigma);  //进行分裂
    doubleVector eachCenterDist(doubleVector t1, doubleVector t2, int i, int j);  //计算聚类中心两两间的距离
    vector<doubleVector> distSort(vector<doubleVector> eachDist);   //按距离进行排序
    vector<doubleVector> Union(vector<doubleVector> mCenter, vector<doubleVector> sortDist); //进行合并
    void Output(vector<clusterVector> cluster);  //结果输出
    
    
    //主函数
    int main()
    {
    vector<doubleVector> srcInf;
    srcInf = getInf();
    ISODATA(srcInf);
    }
    
    
    
    
    //迭代开始引擎
    void ISODATA(vector<doubleVector> srcInf)
    {
    int c;
    int i, j;
    int iter=1;
    int lable;
    vector<doubleVector> mCenter;
    vector<clusterVector> cluster;
    vector<doubleVector> wMean;   //均值向量
    vector<doubleVector> avgDist;
    doubleVector all_AvgDis;
    vector<doubleVector> devVal;  //标准偏差值
    vector<doubleVector> eachDist;  //两两聚类中心距离
    vector<doubleVector> eachDistSort;  //两两聚类中心距离
    doubleVector devMax;   //最大偏差值
    double sigma;
    
    
    start:
    printf("聚类开始:\n");
    
    
    
    
    //初始化类聚中心
    step1:   
    srand(time(NULL));
    int chooseNum;
    if(mCenter.empty()==NULL)
    mCenter.clear();
    
    
    mCenter.resize(cNum);
    for(i=0; i<cNum; i++)
    {
    chooseNum = rand()%(int)(srcInf.size()/cNum)+i*(srcInf.size()/cNum);
    for(j=0; j<dimNum; j++)
    mCenter[i].push_back(srcInf[chooseNum][j]);
    }
    
    
    
    
    //根据距离归类
    step2:  
    if(cluster.empty()==NULL)
    cluster.clear();
    
    
    cluster.resize(2*cNum);
    for(i=0; i<srcInf.size(); i++)
    {
    lable = getClusterNum(mCenter, srcInf[i]);
    cluster[lable].push_back(srcInf[i]);
    }
    
    
    
    
    //舍弃过小的类
    step3: 
    for(i=0; i<cluster.size(); )
    {
    if(cluster[i].size()<minNum)
    {
    cluster.erase(cluster.begin()+i);
    if(i<mCenter.size())
    mCenter.erase(mCenter.begin()+i);
    }
    
    else
    i++;
    }
    c = mCenter.size();
    
    
    
    
    //更新均值向量
    step4:  
    if(wMean.empty()==NULL)
    wMean.clear();
    
    
    for(i=0; i<cluster.size(); i++)
    wMean.push_back(get_wMean(cluster[i]));
    
    
    
    //获取各平均距离
    step5:
    if(avgDist.empty()==NULL)
    avgDist.clear();
    
    
    for(i=0; i<cluster.size(); i++)   //计算Wi中所有样本距其相应聚类中心的平均距离
    avgDist.push_back(averageDist(mCenter[i], cluster[i]));  
    
    
    all_AvgDis = allAvgDist(avgDist);  //计算所以样本距其相应的聚类中心的平均值
    
    
    
    
    //判断分裂、合并及迭代的运算步骤
    step7:
    if(iter==iterNum)   //步骤(1)
    {
    
    // connectNum = 0;
    goto step11;
    }
    
    
    if(c<=expectNum/2)//步骤(2)
    goto step8;
    
    
    if(iter%2==0 || c>=2*expectNum)//步骤(3)
    goto step11;
    
    
    
    
    //计算标准偏差
    step8:
    if(devVal.empty()==NULL)
    devVal.clear();
    
    
    for(i=0; i<mCenter.size(); i++)   //计算标准偏差
    devVal.push_back(getDeviation(mCenter[i], cluster[i]));
    
    
    
    
    
    
    //计算标准偏差中偏差最大值
    step9:
    if(devMax.empty()==NULL)
    devMax.clear();
    
    
    for(i=0; i<devVal.size(); i++)    //计算标准偏差中偏差最大值
    devMax.push_back(getMaxDev(devVal[i]));
    
    
    
    
    
    
    //进行分裂
    step10:
    for(i=0; i<devMax.size(); i++)
    {
    if((devMax[i]>splitVar && cluster[i].size()>2*minNum) || c<=expectNum/2)
    {
    sigma = alpha*devMax[i];
    mCenter.push_back(clusterSplit(wMean[i], sigma));
    mCenter.push_back(clusterSplit(wMean[i], -sigma));
    mCenter.erase(mCenter.begin()+i);
    }
    }
    c = mCenter.size();
    
    
    
    
    //计算两两聚类间的距离
    step11:
    if(eachDist.empty()==NULL)
    eachDist.clear();
    
    
    for(i=0; i<mCenter.size()-1; i++)
    for(j=i+1; j<mCenter.size(); j++)
    { 
    eachDist.push_back(eachCenterDist(mCenter[i], mCenter[j], i, j));
    
    }
    
    
    
    
    
    
    //对距离进行排序
    step12:
    eachDistSort = distSort(eachDist);
    
    
    
    
    //进行合并
    step13:
    mCenter = Union(mCenter, eachDistSort);
    c = mCenter.size();
    
    
    
    
    step14:
    if(iter==iterNum)
    {
    printf("类聚结果为:\n");
    Output(cluster);
    system("pause");
    return;
    }
    
    
    else
    {
    iter++;
    goto step2;
    }
    
    
    }
    
    
    
    
    
    
    //获取文件数据
    vector<doubleVector> getInf()
    {
    int i=1;
    vector<doubleVector> dst;
    doubleVector temp;
    double num;
    
    FILE *fp;
    
    fp = fopen("Inf.txt","r");
    //fp = fopen("Inf.txt", "r");
    
    if(fp == NULL)
    printf("Open file error!\n");
    
    //读取文件的数据
    while(fscanf(fp, "%lf", &num)!=EOF)
    {
    temp.push_back(num);
    if(i%3==0)
    {
    dst.push_back(temp);
    temp.clear();
    }
    i++;
    }
    
    fclose(fp);
    
    return dst;
    }
    
    
    
    
    //计算欧式距离
    double getEUCdis(doubleVector t1, doubleVector t2)
    {
    double distance=0;
    int i;
    
    
    for(i=0; i<dimNum; i++)
    distance += (t1[i]-t2[i])*(t1[i]-t2[i]);
    
    
    return sqrtf(distance);
    }
    
    
    //根据初始中心进行归类
    int getClusterNum(vector<doubleVector> mCenter, doubleVector srcInf)
    {
    double Dis;
    double minDis = getEUCdis(mCenter[0], srcInf);
    int i, lable=0;
    
    
    for(i=1; i<mCenter.size(); i++)
    {
    Dis = getEUCdis(mCenter[i], srcInf);
    if(Dis<minDis)
    {
    minDis = Dis;
    lable = i;
    }
    }
    
    
    return lable;
    }
    
    
    
    
    //计算均值向量
    doubleVector get_wMean(clusterVector cluster)
    {
    doubleVector wMean;
    double temp[dimNum];
    int i, j;
    
    
    for(i=0; i<dimNum; i++)
    temp[i] = 0;
    
    
    for(i=0; i<cluster.size(); i++)
    for(j=0; j<dimNum; j++)
    temp[j] += cluster[i][j];
    
    
    for(i=0; i<dimNum; i++)
    temp[i] = temp[i]/cluster.size();
    
    
    wMean.clear();
    for(i=0; i<dimNum; i++)
    wMean.push_back(temp[i]);
    
    
    return wMean;
    }
    
    
    
    
    //计算类聚中心m[i]的平均距离
    doubleVector averageDist(doubleVector mCenter, clusterVector cluster)
    {
      int i, j;
      doubleVector avgDist;
    double temp[dimNum]={0};
    
    
    for(i=0; i<cluster.size(); i++)
    for(j=0; j<dimNum; j++)
    temp[j] += cluster[i][j];
    
    
    for(i=0; i<dimNum; i++)
    temp[i] /= cluster.size();
    
    
    avgDist.clear();
    for(i=0; i<dimNum; i++)
    avgDist.push_back(temp[i]);
    
    
    return avgDist;
    
    
    }
    
    
    
    
    //计算所以样本距其相应的聚类中心的平均值
    doubleVector allAvgDist(vector<doubleVector> avgDis)
    {
    int i, j;
    doubleVector allAvg;
    double temp[dimNum]={0};
    
    
    for(i=0; i<avgDis.size(); i++)
    for(j=0; j<dimNum; j++)
    temp[j] += (i+1)*avgDis[i][j];
    
    
    for(i=0; i<dimNum; i++)
    temp[i] /= avgDis.size();
    
    
    allAvg.clear();
    for(i=0; i<dimNum; i++)
    allAvg.push_back(temp[i]);
    
    
    return allAvg;
    }
    
    
    
    
    //计算每一个聚类的标准偏差
    doubleVector getDeviation(doubleVector mCenter, clusterVector cluster)
    {
    doubleVector dst;
    int i, j;
    double temp[dimNum]={0};
    
    
    for(i=0; i<cluster.size(); i++)
    for(j=0; j<dimNum; j++)
    temp[j] += (cluster[i][j]-mCenter[j])*(cluster[i][j]-mCenter[j]);
    
    
    dst.clear();
    for(i=0; i<dimNum; i++)
    {
    temp[i] /= cluster.size();
    temp[i] = sqrtf(temp[i]);
    dst.push_back(temp[i]);
    }
    
    
    return dst;
    
    
    }
    
    
    
    
    //获取最大标准偏差
    double getMaxDev(doubleVector Dev)
    {
    int i;
    double max = Dev[0];
    
    
    for(i=1; i<dimNum; i++)
    if(max<Dev[i])
    max = Dev[i];
    
    
    return max;
    }
    
    
    
    
    //进行分裂
    doubleVector clusterSplit(doubleVector wMean, double sigma)
    {
    int i;
    doubleVector newMean;
    double temp;
    
    
    newMean.clear();
    for(i=0; i<dimNum; i++)
    {
    temp = wMean[i]+sigma;
    newMean.push_back(temp);
    }
    
    
    return newMean;
    }
    
    
    
    
    //计算聚类中心两两间的距离
    doubleVector eachCenterDist(doubleVector t1, doubleVector t2, int x, int y)
    {
    int i;
    doubleVector dist;
    
    
    dist.clear();
    for(i=0; i<dimNum; i++)
    dist.push_back(fabs(t1[i]-t2[i]));
    
    
    dist.push_back(x);
    dist.push_back(y);
    
    
    return dist;
    }
    
    
    
    
    //按距离进行排序
    vector<doubleVector> distSort(vector<doubleVector> eachDist)
    {
    int i, j, l;
    vector<doubleVector> dst;
    doubleVector maxEachDist;
    double temp;
    doubleVector tempVet;
    double min;
    
    
    dst = eachDist;
    //寻找每组中最大的距离
    maxEachDist.clear();
    for(i=0; i<eachDist.size(); i++)
    maxEachDist.push_back(getMaxDev(eachDist[i]));
    
    
    //排序
    for(i=0; i<maxEachDist.size(); i++)
    {
    l=i;
    min = maxEachDist[i]; 
    for(j=i+1; j<maxEachDist.size(); j++)
    if(min>maxEachDist[j])
    {
    min = maxEachDist[j];
    l = j;
    }
    
    
    temp = maxEachDist[i];
    maxEachDist[i] = maxEachDist[l];
    maxEachDist[l] = temp;
    
    
    tempVet = dst[i];
    dst[i] = dst[l];
    dst[l] = tempVet;
    }
    
    
    return dst;
    }
    
    
    
    
    //进行合并
    vector<doubleVector> Union(vector<doubleVector> mCenter, vector<doubleVector> sortDist)
    {
    int i[connectNum], j[connectNum];
    int m, n, delNum=0;
    vector<doubleVector> newCenter;
    vector<int> del;
    doubleVector temp;
    
    
    newCenter = mCenter;
    
    
    //可联合数量
    for(m=0; m<connectNum; m++)
    for(n=0; n<dimNum; n++)
    if(sortDist[m][n]<connectVar)
    {
    delNum++;
    break;
    }
    
    
    //进行联合
    for(m=0; m<delNum; m++)
    {
    i[m] = sortDist[m][dimNum];
    j[m] = sortDist[m][dimNum+1];
    
    
    for(n=0; n<dimNum; n++)
    temp.push_back((i[m]*mCenter[i[m]][n]+j[m]*mCenter[j[m]][n])/(i[m]+j[m]));
    
    
    newCenter.push_back(temp);
    }
    
    
    //避免重复删除
    for(m=0; m<delNum; m++)
    del.push_back(i[m]);
    
    for(n=0; n<delNum; n++)
    {
    if(del[n]==j[n])
    continue;
    else
    del.push_back(j[n]);
    }
    
    
    
      for(m=0; m<del.size(); m++)
      newCenter[del[m]].clear();
    
    
    for(m=0; m<newCenter.size(); )
    {
    if(newCenter[m].empty())
    newCenter.erase(newCenter.begin()+m);
    else
    m++;
    }
    
    return newCenter;
    }
    
    
    
    
    //结果输出
    void Output(vector<clusterVector> cluster)
    {
    int i, j, k;
    
    
    for(i=0; i<cluster.size(); i++)
    {
    printf("\n类聚%d :\n", i+1);
    for(j=0; j<cluster[i].size(); j++)
    printf("%lf  %lf  %lf  %lf  %lf\n", cluster[i][j][0], cluster[i][j][1], cluster[i][j][2], cluster[i][j][4], cluster[i][j][5]);
    }
    }
    

    运行结果:

    第一次运行:

    在这里插入图片描述

    第二次运行:

    在这里插入图片描述
    在这里插入图片描述

    运行第三次

    在这里插入图片描述
    在这里插入图片描述

    第四次运行:

    在这里插入图片描述

    第五次运行:

    在这里插入图片描述

    K-Means算法与模糊聚类算法优缺点对比

    K-Means算法

    优点:

    1.算法快速、简单;

    2.对大数据集有较高的效率并且是可伸缩性的;

    3.时间复杂度近于线性,而且适合挖掘大规模数据集。

    K-Means聚类算法的时间复杂度是O(nkt) ,其中n代表数据集中对象的数量,t代表着算法迭代的次数,k代表着簇的数目。

    缺点:
    1.在 K-means 算法中 K 是事先给定的,这个 K 值的选定是非常难以估计的

    2.在 K-means 算法中,首先需要根据初始聚类中心来确定一个初始划分,然后对初始划分进行优化。这个初始聚类中心的选择对聚类结果有较大的影响,一旦初始值选择的不好,可能无法得到有效的聚类结果

    3.从 K-means 算法框架可以看出,该算法需要不断地进行样本分类调整,不断地计算调整后的新的聚类中心,因此当数据量非常大时,算法的时间开销是非常大的。所以需要对算法的时间复杂度进行分析、改进,提高算法应用范围

    模糊聚类算法

    优点:

    1.FCM方法会计算每个样本对所有类的隶属度,拥有样本分类结果可靠性的计算方法;

    2.样本分类更加保险

    缺点:
    计算量较大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最近邻点。其时间复杂度为O(n3log2n),且存储开销大,很难处理大规模的数据

    对比

    k均值聚类:一种硬聚类算法,隶属度只有两个取值0或1,提出的基本根据是“类内误差平方和最小化”准则;
    模糊c均值聚类算法:一种模糊聚类算法,是k均值聚类算法的推广形式,隶属度取值为[0 1]区间内的任何一个数,提出的基本根据是“类内加权误差平方和最小化”准则;
    这两个方法都是迭代求取最终的聚类划分,即聚类中心与隶属度值。两者都不能保证找到问题的最优解,都有可能收敛到局部极值,模糊c均值甚至可能是鞍点。

    展开全文
  • 基于Matlab模糊聚类Kmeans算法,有兴趣和需要的可以研究
  • 基于模糊聚类和格子玻尔兹曼方法的快速鲁棒水平集图像分割方法
  • 针对模糊C均值(FCM)算法聚类数需要预先设定的问题,提出了一种新的模糊聚类有效性指标。首先,计算簇中每个属性的方差,给方差较小的属性赋予较大的权值,给方差较大的属性赋予较小的权值,得到一种基于属性加权的...
  • matlab模糊聚类算法进行图像分割的源程序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,763
精华内容 6,705
关键字:

模糊聚类