精华内容
下载资源
问答
  • 模糊均值聚类算法。
  • 模糊c均值聚类 matlab

    2012-05-07 12:45:06
    简单的模糊c-均值聚类matlab程序 希望对大家能够有所帮助
  • 聚类分割算法是图像处理中的基本操作,文件中包含了使用模糊C-均值实现聚类分割的算法原理以及MAtlab源程序 聚类分割算法是图像处理中的基本操作,文件中包含了使用模糊C-均值实现聚类分割的算法原理以及MAtlab源...
  • 针对模糊C均值聚类算法(FCM)存在对初始聚类中心敏感,易陷入局部最优解的不足,将改进的粒子群聚类算法与FCM算法相结合,提出了一种基于粒子群优化的模糊C均值聚类算法。该算法对粒子群初始化空间及粒子移动最大速度...
  • 基于模糊C均值的快速点云的聚类分析代码,可用于模糊聚类
  • matlab均值聚类的基本代码,代码参考自周志华《机器学习》9.4.1节而写的,代码使用matlab矩阵序列化操作,速度会快一点,本代码仅供参考,请尊重原创
  • 基于遗传模拟退火算法的模糊C均值聚类算法(MATLAB自带的遗传算法工具箱),注释清楚,可直接更改使用,代码在MATLAB2016里运行通过!
  • 亲测可用!图像模糊C均值聚类分割matlab代码,聚类分割后显示图像。 仅需要自己修改读图路径。
  • 自己写的模糊C均值聚类算法MATLAB实现
  • matlab实现模糊C均值聚类,附带包含600个2维数据的数据集,可视化展示结果。数据集有3类,分别分布在第一、二 三象限。
  • 模糊c-均值(FCM)聚类算法在matlab中实现,已测试通过
  • 分析在有效 性、快速性等性能指标方面,与模糊 C 均值聚类算法、基于遗传的模糊 C-均值聚类算法相 比,模拟退火算法与遗传算法相结合后用于模糊 C-均值聚类的算法所带来的优越性。 3、理解混合粒子群算法(基于自然...
  • 使用matlab语言来实现模糊c均值聚类,从而实现对图像的分割
  • 我的题目是模糊聚类分析的有效性问题初探,FCM算法是我论文中不可或缺的部分,在此我将FCM算法的两种迭代形式的MATLAB代码写于下,也许有的同学会用得着关键技术模糊C均值聚类(FCM),即众所周知的模糊ISODATA,是用隶属...

    应用背景数学系本科毕业设计中有不少是与模糊数学相关的,我的题目是模糊聚类分析的有效性问题初探,FCM算法是我论文中不可或缺的部分,在此我将FCM算法的两种迭代形式的MATLAB代码写于下,也许有的同学会用得着

    关键技术

    模糊C均值聚类(FCM),即众所周知的模糊ISODATA,是用隶属度确定每个数据点属于某个聚类的程度的一种聚类算法。1973年,Bezdek提出了该算法,作为早期硬C均值聚类(HCM)方法的一种改进。

    FCM把n个向量xi(i=1,2,…,n)分为c个模糊组,并求每组的聚类中心,使得非相似性指标的价值函数达到最小。FCM与HCM的主要区别在于FCM用模糊划分,使得每个给定数据点用值在0,1间的隶属度来确定其属于各个组的程度。与引入模糊划分相适应,隶属矩阵U允许有取值在0,1间的元素。不过,加上归一化规定,一个数据集的隶属度的和总等于1.

    FCM的价值函数(或目标函数)就是所有个点隶属度乘以该点与中心的欧氏距离之和。

    在批处理方式运行时,FCM用下列步骤确定聚类中心ci和隶属矩阵U[1]:

    步骤1:用值在0,1间的随机数初始化隶属矩阵U,使其满足式(6.9)中的约束条件

    步骤2:用式(6.12)计算c个聚类中心ci,i=1,…,c。

    步骤3:根据式(6.10)计算价值函数。如果它小于某个确定的阀值,或它相对上次价值函数值的改变量小于某个阀值,则算法停止。

    步骤4:用(6.13)计算新的U矩阵。返回步骤2。

    上述算法也可以先初始化聚类中心,然后再执行迭代过程。由于不能确保FCM收敛于一个最优解。算法的性能依赖于初始聚类中心。因此,我们要么用另外的快速算法确定初始聚类中心,要么每次用不同的初始聚类中心启动该算法,多次运行FCM。

    迭代函数:

    展开全文
  • 模糊C均值聚类算法

    2015-01-19 10:09:11
    自己写的模糊C均值聚类算法,也就是FCM,用matlab写的,希望能帮助大家学习
  • 描述聚类分析是多元统计分析的一种,也是无监督模式识别的一个重要分支,在模式分类 图像处理和模糊规则处理等众多领域中获得最广泛的应用。它把一个没有类别标记的样本按照某种准则划分为若干子集,使相似的样本尽...

    描述

    聚类分析是多元统计分析的一种,也是无监督模式识别的一个重要分支,在模式分类 图像处理和模糊规则处理等众多领域中获得最广泛的应用。它把一个没有类别标记的样本按照某种准则划分为若干子集,使相似的样本尽可能归于一类,而把不相似的样本划分到不同的类中。硬聚类把每个待识别的对象严格的划分某类中,具有非此即彼的性质,而模糊聚类建立了样本对类别的不确定描述,更能客观的反应客观世界,从而成为聚类分析的主流。

    模糊聚类算法是一种基于函数最优方法的聚类算法,使用微积分计算技术求最优代价函数,在基于概率算法的聚类方法中将使用概率密度函数,为此要假定合适的模型,模糊聚类算法的向量可以同时属于多个聚类,从而摆脱上述问题。

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

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

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

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

    模糊的c均值聚类算法:-------- 一种模糊聚类算法,是k均值聚类算法的推广形式,隶属度取值为[0 1]区间内的任何一个数,提出的基本根据是“类内加权误差平方和最小化”准则;

    模糊C 均值聚类算法(FCM,Fuzzy c-means) 是从硬C 均值聚类算法发展而来(HCM,Hardc-means )。

    硬C划分和模糊C 划分

    fde71c675a2fbdf7a201f210bbcaa34a.png

    FCM算法原理

    c0d85cf86907fc93600cbafac52ce621.png

    FCM 算法步骤

    给定聚类类别数C,设定迭代收敛条件,初始化各个聚类中心;

    (1)重复下面的运算,直到各个样本的隶属度值稳定:

    (2)用当前的聚类中心根据公式(6) 计算隶属度函数;

    A.用当前的隶属度函数根据公式(5) 重新计算各个聚类的中心。

    B.当算法收敛时,就得到了各类的聚类中心和各个样本对于各类的隶属度值,从而完成了模糊聚类划分。

    算法实现

    ·采用VC++进行编写

    文档的读取

    #include “data.h”

    //函数定义

    double **DataRead(char*name,int row,intcol)

    {

    double**p=new double* [row];

    ifstreaminfile;

    infile.open(name,ios::in);

    for(inti=0;i《row;i++)

    {

    p[i]=newdouble[col];

    for(intj=0;j《col;j++)

    {

    infile》》p[i][j];

    }

    }

    infile.close();

    cout《《“成功读取数据文件:”《《name《《“!\n”;

    returnp;

    //释放内存

    for(i=0;i《row;i++)

    {

    delete[]p[i];

    }

    delete[]p;

    }

    文档的保存

    #include “data.h”

    void DataSave(double**data,int row,intcol,char*name)

    {

    inti,j;

    ofstreamoutfile;

    //打开文件,输出数据

    outfile.open(name,ios::out);

    outfile.setf(ios::fixed);

    outfile.precision(4);

    for(i=0;i《row;i++)

    {

    for(j=0;j《col;j++)

    {

    outfile《《data[i][j]《《“”;

    }

    outfile《《endl;

    }

    outfile《《endl《《endl;

    outfile.close();

    }

    数据标准化处理

    #include “data.h”

    double **Standardize(double **data,introw,int col)

    {

    inti,j;

    double*a=new double[col]; //矩阵每列的最大值

    double*b=new double[col]; //矩阵每列的最小值

    double*c=new double[row]; //矩阵列元素

    for(i=0;i《col;i++)

    {

    //取出数据矩阵的各列元素

    for(j=0;j《row;j++)

    {

    c[j]=Data[j][i];

    }

    a[i]=c[0],b[i]=c[0];

    for(j=0;j《row;j++)

    {

    //取出该列的最大值

    if(c[j]》a[i])

    {

    a[i]=c[j];

    }

    //取出该列的最小值

    if(c[j]《b[i])

    {

    b[i]=c[j];

    }

    }

    }

    //数据标准化

    for(i=0;i《row;i++)

    {

    for(j=0;j《col;j++)

    {

    data[i][j]=(data[i][j]-b[j])/(a[j]-b[j]);

    }

    }

    cout《《“完成数据极差标准化处理!\n”;

    delete[]a;

    delete[]b;

    delete[]c;

    returndata;

    }

    生成样本虑属矩阵

    #include “data.h”

    void Initialize(double **u, int k, introw)

    {

    inti,j;

    //初始化样本隶属度矩阵

    srand(time(0));

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    u[i][j]=(double)rand()/RAND_MAX;//得到一个小于1的小数隶属度

    }//rand()函数返回0和RAND_MAX之间的一个伪随机数

    }

    }

    数据归一化处理

    #include “data.h”

    void Normalize(double **u,int k,intcol)

    {

    inti,j;

    double*sum=new double[col];

    //矩阵U的各列元素之和

    for(j=0;j《col;j++)

    {

    doubledj=0;

    for(i=0;i《k;i++)

    {

    dj=dj+U[i][j];

    sum[j]=dj;//隶属度各列之和

    }

    }

    for(i=0;i《k;i++)

    {

    for(j=0;j《col;j++)

    {

    u[i][j]=U[i][j]/sum[j];

    }//规一化处理(每列隶属度之和为1)

    }

    }

    迭代过程

    #include “data.h”

    #include “func.h”//对模糊C均值进行迭代运算,并返回有效性评价函数的值

    doubleUpdate(double**u,double**data,double**center,int row,int col, int k)

    {

    inti,j,t;

    double**p=NULL;

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    //模糊指数取2

    u[i][j]=pow(u[i][j],2);

    }

    }

    //根据隶属度矩阵计算聚类中心

    p=MatrixMul(u,k,row,data,row,col);

    for(i=0;i《k;i++)

    {

    //计算隶属度矩阵每行之和

    doublesi=0;

    for(j=0;j《row;j++)

    {

    si+=u[i][j];

    }

    for(t=0;t《col;t++)

    {

    center[i][t]=p[i][t]/si; //类中心

    }

    }

    //计算各个聚类中心i分别到所有点j的距离矩阵dis(i,j)

    double*a=new double[col]; //第一个样本点

    double*b=new double[col]; //第二个样本点

    double**dis=newdouble*[k]; //中心与样本之间距离矩阵

    for(i=0;i《k;i++)

    {

    dis[i]=newdouble[row];

    }

    for(i=0;i《k; i++)

    {

    //聚类中心

    for(t=0;t《col; t++)

    {

    a[t]=center[i][t]; //暂存类中心

    }

    //数据样本

    for(j=0;j《row; j++)

    {

    for(t=0;t《col; t++)

    {

    b[t]=data[j][t];//暂存一样本

    }

    doubled=0;

    //中心与样本之间距离的计算

    for(t=0;t《col; t++)

    {

    d+=(a[t]-b[t])*(a[t]-b[t]); //d为一中心与所有样本的距离的平方和

    }

    dis[i][j]=sqrt(d); //距离

    }

    }

    //根据距离矩阵计算隶属度矩阵

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    doubletemp=0;

    for(t=0;t《k;t++)

    {

    //dis[i][j]依次除以所在列的各元素,加和;

    //模糊指数为2.0

    temp+=pow(dis[i][j]/dis[t][j],2/(2.0-1));//一个类中心和一个元素的距离平方与

    }

    u[i][j]=1/temp;//所有类与该元素距离平方的和的商

    }

    }

    //计算聚类有效性评价函数

    doublefunc1=0;

    for(i=0;i《k;i++)

    {

    doublefunc2=0;

    for(j=0;j《row;j++)

    {

    func2+=pow(u[i][j],2.0)*pow(dis[i][j],2);

    }

    func1+=func2;

    }

    doubleobj_fcn=1/(1+func1);

    returnobj_fcn;

    //内存释放

    delete[]a;

    delete[]b;

    for(i=0;i《k;i++)

    {

    delete[]dis[i];

    }

    delete[]dis;

    }

    详细过程

    #include “data.h”

    #include “func.h”

    #include “max.h”

    //全局变量定义

    double **Data; //数据矩阵

    double **Center; //聚类中心矩阵

    double **U; //样本隶属度矩阵

    int m; //样本总数

    int n; //样本属性数

    int k; //设定的划分类别数

    int main()

    {

    intLab; //数据文件标号

    intnum; //算法运行次数

    ///

    cout《《“模糊C均值聚类算法:”《《endl;

    cout《《“1-iris.txt; 2-wine.txt; 3-ASD_12_2.txt; 4-ASD_14_2.txt”《《endl;

    cout《《“请选择数据集: Lab=”;

    cin》》Lab;

    cout《《“设定运行次数: mum=”;

    cin》》num;

    //各次运行结束后的目标函数

    double*Index=new double[num];

    //各次运行结束后的聚类正确率

    double*R=new double [num];

    //num次运行的平均目标函数及平均正确率

    doubleM_Index=0;

    doubleM_R=0;

    //FCM聚类算法运行num次,并保存记录与结果

    for(inti=0;i《num;i++)

    {

    intj;

    doubleepsilon=1e-4;

    inte=0;

    intnx=0;

    //记录连续无改进次数

    intE[200]={0};

    if(i》0)

    {

    cout《《endl《《endl;

    cout《《setfill(‘#’)《《setw(10)《《endl;

    }

    cout《《“第”《《i+1《《“次运行记录:”《《endl;

    //读取数据文件

    if(Lab==1)

    {

    m=150;

    n=4;

    k=3;

    Data=DataRead(“dataset\\iris.txt”,m,n);

    }

    elseif(Lab==2)

    {

    m=178;

    n=13;

    k=3;

    Data=DataRead(“dataset\\wine.txt”,m,n);

    }

    elseif(Lab==3)

    {

    m=535;

    n=2;

    k=12;

    Data=DataRead(“dataset\\ASD_12_2.txt”,m,n);

    }

    elseif(Lab==4)

    {

    m=685;

    n=2;

    k=14;

    Data=DataRead(“dataset\\ASD_14_2.txt”,m,n);

    }

    //数据极差标准化处理

    Data=Standardize(Data,m,n);

    //聚类中心及隶属度矩阵,内存分配

    Center=newdouble*[k];

    U=newdouble *[k];

    for(j=0;j《k;j++)

    {

    Center[j]=newdouble[n];

    U[j]=newdouble[m];

    }

    //隶属度矩阵的初始化

    Initialize(U,k, m);

    //对隶属度矩阵进行归一化

    Normalize(U,k,m);

    //历次迭代过程中的目标函数

    doubleObjfcn[100]={0};

    cout《《“第”《《i+1《《“次运行记录:”《《endl;

    cout《《“开始迭代过程!”《《endl;

    cout《《“*******************************”《《endl;

    //输出精度为小数点后5位

    cout.precision(5);

    //固定格式

    cout.setf(ios::fixed);

    //目标函数连续20代无改进,停止该次聚类迭代过程

    while(e《20)

    {

    nx++;

    //聚类迭代过程

    Objfcn[nx]=Update(U,Data,Center,m,n,k);

    //统计目标函数连续无改进次数e

    if(nx》0&& Objfcn[nx]-Objfcn[nx-1]《epsilon )

    {

    e++;

    }

    else

    {

    e=0;

    }

    E[nx]=e;

    }

    //输出结果到文件,保存

    ofstreamoutfile(“运行记录.txt”,ios::app);

    outfile《《“第”《《i+1《《“次运行记录:”《《endl;

    outfile《《“开始迭代过程!”《《endl;

    outfile《《“*******************************”《《endl;

    outfile.precision(5);

    outfile.setf(ios::fixed);

    for(intn1=1;n1《=nx;n1++)

    {

    cout《《“e[”《《setw(2)《《n1《《“]=”《《setw(2)《《E[n1]《《“ Objfcn[”

    《《setw(2)《《n1《《“]=”《《Objfcn[n1]《《“\n”;

    //保存数据文件

    outfile《《“e[”《《setw(2)《《n1《《“]=”《《setw(2)《《E[n1]《《“ Objfcn[”

    《《setw(2)《《n1《《“]=”《《Objfcn[n1]《《“\n”;

    }

    cout《《endl;

    outfile《《endl;

    outfile.close();

    //本次运行的最大目标函数

    Index[i]=Objfcn[nx];

    //保存聚类正确率,输出聚类结果:

    R[i]=Result(Lab,U, k, m, i);

    //内存释放

    for(j=0;j《k;j++)

    {

    delete[]Center[j];

    delete[]U[j];

    }

    delete[]Center;

    delete[]U;

    }

    //统计平均///

    doubletemp1=0, temp2=0;

    for(i=0;i《num;i++)

    {

    temp1+=Index[i];

    temp2+=R[i];

    }

    //计算各次结果的统计平均

    M_Index=(double)temp1/num;

    M_R=(double)temp2/num;

    cout《《“//”《《endl;

    cout《《num《《“次运行,平均聚类正确率: ”《《100*M_R《《“%”《《endl;

    //输出精度为小数点后6位

    cout.precision(6);

    //固定格式

    cout.setf(ios::fixed);

    cout《《“平均目标函数:”《《M_Index《《endl;

    //统计结果文件保存

    ofstreamresultfile(“聚类结果.txt”,ios::app);

    resultfile《《“//”《《endl;

    resultfile《《num《《“次运行,平均聚类正确率: ”《《100*M_R《《“%”《《endl;

    //输出精度为小数点后6位

    resultfile.precision(6);

    //固定格式

    resultfile.setf(ios::fixed);

    resultfile《《“平均目标函数:”《《M_Index《《endl;

    return0;

    }

    打开APP阅读更多精彩内容

    点击阅读全文

    展开全文
  • fcm Matlab中的模糊c均值聚类算法
  • 针对传统的模糊C均值聚类算法(FCM)在图像分割中对噪声十分敏感这一局限性,提出一种自适应的FCM图像分割方法。该方法充分考虑图像像素的灰度信息和空间信息,根据像素的空间位置自适应地计算一个合适的相似度距离...
  • 目录1.K-means算法1.1算法流程1.2程序实现实验结果原始数据集聚类结果2.FCM算法2.1算法流程功能快捷键合理的创建标题,有助于目录的...在科学计算领域,聚类算法一般都是作为其他算法分析的基础,对数据进行聚类可以


    在科学计算领域,聚类算法一般都是作为其他算法分析的基础,对数据进行聚类可以从整体上分析数据的一些特性。聚类有很多的算法,K-means是最简单最实用的一种算法,FCM算法则是K-means算法融合模糊理论的一种改进算法。本文将简述这两种算法,并在MATLAB中实现这两种算法对数据的聚类。

    1.K-means算法

    1.1算法流程

    K-means算法是一种迭代求解的聚类分析算法,其步骤是,预将数据分为K组,则随机选取K个对象作为初始的聚类中心,然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。每分配一个样本,聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是没有(或最小数目)对象被重新分配给不同的聚类,没有(或最小数目)聚类中心再发生变化,误差平方和局部最小。
    1.首先确定一个k值,即我们希望将数据集经过聚类得到k个集合。
    2.从数据集中随机选择k个数据点作为聚类中心。
    3.对数据集中每一个点,计算其与每一个聚类中心的距离(如欧式距离),离哪个聚类中心近,就划分到那个聚类中心所属的集合。
    4.把所有数据归好集合后,一共有k个集合。然后重新计算每个集合的聚类中心。
    5.如果新计算出来的聚类中心和原来的聚类中心之间的距离小于某一个设置的阈值(表示重新计算的聚类中心的位置变化不大,趋于稳定),我们可以认为聚类已经达到期望的结果,算法终止。
    6.如果新聚类中心和原聚类中心距离变化很大,需要迭代3至5步骤。

    1.2程序实现

    下面是在MATLAB中实现K-means算法的程序。
    这里使用的数据集dataSet由3个各150个样本的高斯分布组成,后面FCM算法的实现也是如此。程序中设置聚类数为3,初始类中心为迭代开始前在数据集中随机生成,随后计算样本点到每一个类中心距离,这里的距离选取的是欧氏距离,最后按标号将数据分类,求各类中心距离的平均值。程序设置的迭代终止条件是循环100次。迭代结束后将3类样本点以不同颜色显示区分,并标出类中心。

    %第一类数据
    a=[0 0 ];  
    S1=[.1 0 ;0 .1];  
    data1=mvnrnd(a,S1,150);   %产生高斯分布数据
    %第二类数据
    b=[0.8 0.8 ];
    S2=[.1 0 ;0 .1];
    data2=mvnrnd(b,S2,150);
    %第三类数据
    c=[-0.8 0.8 ];
    S3=[.1 0 ;0 .1];
    data3=mvnrnd(c,S3,150);
    %显示数据
    plot(data1(:,1),data1(:,2),'c*');
    hold on;
    plot(data2(:,1),data2(:,2),'r+');
    plot(data3(:,1),data3(:,2),'gd');
    grid on;
    %三类数据合成一个不带标号的数据集
    dataSet=[data1;data2;data3]; 
     
    %K-means 聚类
    N=3;
    [m, n] = size(dataSet);
    re = zeros (m, n+1);
    center = zeros(N, n);
    %初始化聚类中心
    %设置聚类数目
    re(:, 1:n) = dataSet(:,:);
    for x=1:N
        center (x, :) =dataSet( randi (450, 1), :); %第一次随机产生聚类中心
    end
    for i = 1:100
        distence=zeros(1, N);
        num=zeros(1, N);
        new_center=zeros(N, n);
    %更新c
    for x=1:m
        for y=1:N
            distence(y) =norm(dataSet(x, :)-center(y, :));%计算到每个类的距离
        end
        [~, temp] =min(distence);%求最小的距离
        re(x, n+1)=temp;
    end
     
        k=0;
        for y=1:N
            for x=1:m
                if re (x, n+1)==y
                   new_center(y, :)=new_center(y, :)+re(x, 1:n);
                   num(y)=num(y)+1;
                end
            end
            new_center(y, :)=new_center(y, :)/num(y);
            if norm(new_center (y, :) -center (y, :)) <0.1
                k=k+1;
            end
        end
        if k==N
            break;
        else
            center=new_center;
        end
    end
    [m, n]=size(re); 
    %最后显示聚类后的数据
    figure;
    hold on;
    for i=1:m
        if re(i,n) ==1
            plot (re (i, 1), re (i, 2),' c*');
            plot (center (1, 1), center (1, 2),' ko');
        elseif re(i, n) ==2
            plot (re (i, 1), re (i, 2),' r+');
            plot (center (2, 1), center (2, 2),' ko');
        elseif re(i, n) ==3
            plot (re (i, 1), re (i, 2),' gd');
            plot (center (3, 1), center (3, 2),' ko');
        else
            plot (re (i, 1), re (i, 2),' m*');
            plot (center (4, 1), center (4, 2),' ko');
        end
    end
    grid on
    

    1.3实验结果

    原始数据集

    在这里插入图片描述

    聚类结果

    在这里插入图片描述

    2.FCM算法

    2.1算法流程

    FCM算法融合了模糊理论的精髓,相较于k-means的硬聚类,模糊c提供了更加灵活的聚类结果。因为大部分情况下,数据集中的对象不能划分成为明显分离的类,指派一个对象到一个特定的类有些生硬,也可能会出错。因此FCM对每个对象和每个类赋予一个权值即隶属度,指明对象属于该类的程度。当然,基于概率的方法也可以给出这样的权值,但是有时候我们很难确定一个合适的统计模型,因此使用具有自然地、非概率特性的FCM算法就是一个比较好的选择。该方法由Dunn在1973年提出,并由Bezdek在1981年改进,在模式识别被频繁使用。
    FCM算法的隶属度Uij指样本j在类i的隶属度,根据FCM算法的规定样本在各类的隶属度之和为1。

    隶属度和为1
    隶属度的迭代公式如下:
    隶属度的迭代公式
    FCM算法的目标是使得下式——目标函数J收敛于某值或低于某一阈值或两次迭代的J之差低于某值又或是达到规定的迭代次数,此时终止运算。
    目标函数
    1.初始化:通常采用随机初始化。即隶属度随机地选取。类数需要人为选定。
    2.计算聚类中心:FCM中的聚类中心有别于传统聚类中心的地方在于,它是以隶属度为权重做一个加权平均。聚类中心的迭代公式如下:
    聚类中心的迭代公式
    3.更新聚类划分:即更新权重(隶属度)。简单地说,如果样本点越靠近聚类中心,则隶属度越高,反之越低。

    2.2程序设计

    下面是在MATLAB中实现FCM算法的程序。
    这里使用的数据集同K-means算法程序中使用的数据集,程序包括一个FCM算法的子函数和主程序。FCM子函数包括num_data、num_clusters、iter、m和dataSet等5个输入项,分别是样本个数、类别数、迭代次数、指数和数据集;函数包括c、U、J等3个输出项,分别是聚类中心、隶属度矩阵和目标函数值。因为聚类中心的计算公式中需要样本在各类的隶属度,程序中先定义了一个满足隶属度约束条件的初始隶属度矩阵,而后进行聚类中心的计算。聚类中心更新后将计算此时的目标函数,目标函数中的距离度量选取的是欧氏距离。最后更新当前的隶属度矩阵,到这里一次迭代结束。
    主程序里设置的分类数为3,,设置的迭代终止条件是循环100次。程序将显示原始数据集、聚类结果和目标函数J的变化图像。

    FCM子函数

    function [c, U,J] = FCM(num_data,num_clusters,iter,m,dataSet)  
    %--初始化隶属度u,条件是每一列和为1 
    U = rand(num_clusters,num_data);
    col_sum = sum(U);
    U = U./col_sum; 
    % 循环--规定迭代次数作为结束条件
    for i = 1:iter
        %更新c
        for j = 1:num_clusters
            u_ij_m = U(j,:).^m;
            sum_u_ij = sum(u_ij_m);
           c(j,:) = u_ij_m*dataSet./sum_u_ij;
        end
        %-计算目标函数J
        temp1 = zeros(num_clusters,num_data);
        for j = 1:num_clusters
            for k = 1:num_data
                temp1(j,k) = U(j,k)^m*(norm(dataSet(k,:)-c(j,:)))^2;
            end
        end
        J(i) = sum(sum(temp1));
        %更新U
        for j = 1:num_clusters
            for k = 1:num_data
                sum1 = 0;
                for j1 = 1:num_clusters
                    temp = (norm(dataSet(k,:)-c(j,:))/norm(dataSet(k,:)-c(j1,:))).^(2/(m-1));
                    sum1 = sum1 + temp;
                end
                U(j,k) = 1./sum1;
            end
        end
    end
    

    主函数

    %第一类数据
    a=[0 0 ];  
    S1=[.1 0 ;0 .1];  
    data1=mvnrnd(a,S1,150);   %产生高斯分布数据
    %第二类数据
    b=[0.8 0.8 ];
    S2=[.1 0 ;0 .1];
    data2=mvnrnd(b,S2,150);
    %第三类数据
    c=[-0.8 0.8 ];
    S3=[.1 0 ;0 .1];
    data3=mvnrnd(c,S3,150);
    %显示数据
    plot(data1(:,1),data1(:,2),'c*');
    hold on;
    plot(data2(:,1),data2(:,2),'r+');
    plot(data3(:,1),data3(:,2),'gd');
    grid on;
    %三类数据合成一个不带标号的数据类
    dataSet=[data1;data2;data3]; 
     
    num_clusters = 3;%类别数
    iter = 100;%迭代次数
    m = 2;%指数
    num_data = size(dataSet,1);%样本个数
    [c, U,J] = FCM(num_data,num_clusters, iter,m,dataSet);
    figure;
    [m,o] = max(U); %找到所属的类
    index1 = find(o==1);   %索引第一类
    index2 = find(o==2); 
    index3 = find(o==3);
    hold on,plot(dataSet(index1, 1),dataSet(index1, 2),'c*');  %画出来
    hold on,plot(dataSet(index2, 1),dataSet(index2, 2),'r+');  
    hold on,plot(dataSet(index3, 1),dataSet(index3, 2),'gd');  
    plot(c(:,1),c(:,2),'ko');
    grid on
    figure;
    plot(J);
    grid on
    

    2.3实验结果

    原始数据集

    在这里插入图片描述

    聚类结果

    在这里插入图片描述

    目标函数J的变化

    在这里插入图片描述

    展开全文
  • //算法运行次数 /////////////////////////////////////////////////////////////// cout《《“模糊C均值聚类算法:”《《endl; cout《《“1-iris.txt; 2-wine.txt; 3-ASD_12_2.txt; 4-ASD_14_2.txt”《《endl; ...

    算法实现

    ·采用VC++进行编写

    文档的读取

    #include “data.h”

    //函数定义

    double **DataRead(char*name,int row,intcol)

    {

    double**p=new double* [row];

    ifstreaminfile;

    infile.open(name,ios::in);

    for(inTI=0;i《row;i++)

    {

    p[i]=newdouble[col];

    for(intj=0;j《col;j++)

    {

    infile》》p[i][j];

    }

    }

    infile.close();

    cout《《“成功读取数据文件:”《《name《《“!\n”;

    returnp;

    //释放内存

    for(i=0;i《row;i++)

    {

    delete[]p[i];

    }

    delete[]p;

    }

    文档的保存

    #include “data.h”

    void DataSave(double**data,int row,intcol,char*name)

    {

    inTI,j;

    ofstreamoutfile;

    //打开文件,输出数据

    outfile.open(name,ios::out);

    outfile.setf(ios::fixed);

    outfile.precision(4);

    for(i=0;i《row;i++)

    {

    for(j=0;j《col;j++)

    {

    outfile《《data[i][j]《《“”;

    }

    outfile《《endl;

    }

    outfile《《endl《《endl;

    outfile.close();

    }

    数据标准化处理

    #include “data.h”

    double **Standardize(double **data,introw,int col)

    {

    inTI,j;

    double*a=new double[col]; //矩阵每列的最大值

    double*b=new double[col]; //矩阵每列的最小值

    double*c=new double[row]; //矩阵列元素

    for(i=0;i《col;i++)

    {

    //取出数据矩阵的各列元素

    for(j=0;j《row;j++)

    {

    c[j]=Data[j][i];

    }

    a[i]=c[0],b[i]=c[0];

    for(j=0;j《row;j++)

    {

    //取出该列的最大值

    if(c[j]》a[i])

    {

    a[i]=c[j];

    }

    //取出该列的最小值

    if(c[j]《b[i])

    {

    b[i]=c[j];

    }

    }

    }

    //数据标准化

    for(i=0;i《row;i++)

    {

    for(j=0;j《col;j++)

    {

    data[i][j]=(data[i][j]-b[j])/(a[j]-b[j]);

    }

    }

    cout《《“完成数据极差标准化处理!\n”;

    delete[]a;

    delete[]b;

    delete[]c;

    returndata;

    }

    生成样本虑属矩阵

    #include “data.h”

    void IniTIalize(double **u, int k, introw)

    {

    inti,j;

    //初始化样本隶属度矩阵

    srand(time(0));

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    u[i][j]=(double)rand()/RAND_MAX;//得到一个小于1的小数隶属度

    }//rand()函数返回0和RAND_MAX之间的一个伪随机数

    }

    }

    数据归一化处理

    #include “data.h”

    void Normalize(double **u,int k,intcol)

    {

    inti,j;

    double*sum=new double[col];

    //矩阵U的各列元素之和

    for(j=0;j《col;j++)

    {

    doubledj=0;

    for(i=0;i《k;i++)

    {

    dj=dj+U[i][j];

    sum[j]=dj;//隶属度各列之和

    }

    }

    for(i=0;i《k;i++)

    {

    for(j=0;j《col;j++)

    {

    u[i][j]=U[i][j]/sum[j];

    }//规一化处理(每列隶属度之和为1)

    }

    }

    迭代过程

    #include “data.h”

    #include “func.h”//对模糊C均值进行迭代运算,并返回有效性评价函数的值

    doubleUpdate(double**u,double**data,double**center,int row,int col, int k)

    {

    inti,j,t;

    double**p=NULL;

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    //模糊指数取2

    u[i][j]=pow(u[i][j],2);

    }

    }

    //根据隶属度矩阵计算聚类中心

    p=MatrixMul(u,k,row,data,row,col);

    for(i=0;i《k;i++)

    {

    //计算隶属度矩阵每行之和

    doublesi=0;

    for(j=0;j《row;j++)

    {

    si+=u[i][j];

    }

    for(t=0;t《col;t++)

    {

    center[i][t]=p[i][t]/si; //类中心

    }

    }

    //计算各个聚类中心i分别到所有点j的距离矩阵dis(i,j)

    double*a=new double[col]; //第一个样本点

    double*b=new double[col]; //第二个样本点

    double**dis=newdouble*[k]; //中心与样本之间距离矩阵

    for(i=0;i《k;i++)

    {

    dis[i]=newdouble[row];

    }

    for(i=0;i《k; i++)

    {

    //聚类中心

    for(t=0;t《col; t++)

    {

    a[t]=center[i][t]; //暂存类中心

    }

    //数据样本

    for(j=0;j《row; j++)

    {

    for(t=0;t《col; t++)

    {

    b[t]=data[j][t];//暂存一样本

    }

    doubled=0;

    //中心与样本之间距离的计算

    for(t=0;t《col; t++)

    {

    d+=(a[t]-b[t])*(a[t]-b[t]); //d为一中心与所有样本的距离的平方和

    }

    dis[i][j]=sqrt(d); //距离

    }

    }

    //根据距离矩阵计算隶属度矩阵

    for(i=0;i《k;i++)

    {

    for(j=0;j《row;j++)

    {

    doubletemp=0;

    for(t=0;t《k;t++)

    {

    //dis[i][j]依次除以所在列的各元素,加和;

    //模糊指数为2.0

    temp+=pow(dis[i][j]/dis[t][j],2/(2.0-1));//一个类中心和一个元素的距离平方与

    }

    u[i][j]=1/temp;//所有类与该元素距离平方的和的商

    }

    }

    //计算聚类有效性评价函数

    doublefunc1=0;

    for(i=0;i《k;i++)

    {

    doublefunc2=0;

    for(j=0;j《row;j++)

    {

    func2+=pow(u[i][j],2.0)*pow(dis[i][j],2);

    }

    func1+=func2;

    }

    doubleobj_fcn=1/(1+func1);

    returnobj_fcn;

    //内存释放

    delete[]a;

    delete[]b;

    for(i=0;i《k;i++)

    {

    delete[]dis[i];

    }

    delete[]dis;

    }

    详细过程

    #include “data.h”

    #include “func.h”

    #include “max.h”

    //全局变量定义

    double **Data; //数据矩阵

    double **Center; //聚类中心矩阵

    double **U; //样本隶属度矩阵

    int m; //样本总数

    int n; //样本属性数

    int k; //设定的划分类别数

    int main()

    {

    intLab; //数据文件标号

    intnum; //算法运行次数

    ///

    cout《《“模糊C均值聚类算法:”《《endl;

    cout《《“1-iris.txt; 2-wine.txt; 3-ASD_12_2.txt; 4-ASD_14_2.txt”《《endl;

    cout《《“请选择数据集: Lab=”;

    cin》》Lab;

    cout《《“设定运行次数: mum=”;

    cin》》num;

    //各次运行结束后的目标函数

    double*Index=new double[num];

    //各次运行结束后的聚类正确率

    double*R=new double [num];

    //num次运行的平均目标函数及平均正确率

    doubleM_Index=0;

    doubleM_R=0;

    //FCM聚类算法运行num次,并保存记录与结果

    for(inti=0;i《num;i++)

    {

    intj;

    doubleepsilon=1e-4;

    inte=0;

    intnx=0;

    //记录连续无改进次数

    intE[200]={0};

    if(i》0)

    {

    cout《《endl《《endl;

    cout《《setfill(‘#’)《《setw(10)《《endl;

    }

    cout《《“第”《《i+1《《“次运行记录:”《《endl;

    //读取数据文件

    if(Lab==1)

    {

    m=150;

    n=4;

    k=3;

    Data=DataRead(“dataset\\iris.txt”,m,n);

    }

    elseif(Lab==2)

    {

    m=178;

    n=13;

    k=3;

    Data=DataRead(“dataset\\wine.txt”,m,n);

    }

    elseif(Lab==3)

    {

    m=535;

    n=2;

    k=12;

    Data=DataRead(“dataset\\ASD_12_2.txt”,m,n);

    }

    elseif(Lab==4)

    {

    m=685;

    n=2;

    k=14;

    Data=DataRead(“dataset\\ASD_14_2.txt”,m,n);

    }

    //数据极差标准化处理

    Data=Standardize(Data,m,n);

    //聚类中心及隶属度矩阵,内存分配

    Center=newdouble*[k];

    U=newdouble *[k];

    for(j=0;j《k;j++)

    {

    Center[j]=newdouble[n];

    U[j]=newdouble[m];

    }

    //隶属度矩阵的初始化

    Initialize(U,k, m);

    //对隶属度矩阵进行归一化

    Normalize(U,k,m);

    //历次迭代过程中的目标函数

    doubleObjfcn[100]={0};

    cout《《“第”《《i+1《《“次运行记录:”《《endl;

    cout《《“开始迭代过程!”《《endl;

    cout《《“*******************************”《《endl;

    //输出精度为小数点后5位

    cout.precision(5);

    //固定格式

    cout.setf(ios::fixed);

    //目标函数连续20代无改进,停止该次聚类迭代过程

    while(e《20)

    {

    nx++;

    //聚类迭代过程

    Objfcn[nx]=Update(U,Data,Center,m,n,k);

    //统计目标函数连续无改进次数e

    if(nx》0&& Objfcn[nx]-Objfcn[nx-1]《epsilon )

    {

    e++;

    }

    else

    {

    e=0;

    }

    E[nx]=e;

    }

    //输出结果到文件,保存

    ofstreamoutfile(“运行记录.txt”,ios::app);

    outfile《《“第”《《i+1《《“次运行记录:”《《endl;

    outfile《《“开始迭代过程!”《《endl;

    outfile《《“*******************************”《《endl;

    outfile.precision(5);

    outfile.setf(ios::fixed);

    for(intn1=1;n1《=nx;n1++)

    {

    cout《《“e[”《《setw(2)《《n1《《“]=”《《setw(2)《《E[n1]《《“ Objfcn[”

    《《setw(2)《《n1《《“]=”《《Objfcn[n1]《《“\n”;

    //保存数据文件

    outfile《《“e[”《《setw(2)《《n1《《“]=”《《setw(2)《《E[n1]《《“ Objfcn[”

    《《setw(2)《《n1《《“]=”《《Objfcn[n1]《《“\n”;

    }

    cout《《endl;

    outfile《《endl;

    outfile.close();

    //本次运行的最大目标函数

    Index[i]=Objfcn[nx];

    //保存聚类正确率,输出聚类结果:

    R[i]=Result(Lab,U, k, m, i);

    //内存释放

    for(j=0;j《k;j++)

    {

    delete[]Center[j];

    delete[]U[j];

    }

    delete[]Center;

    delete[]U;

    }

    //统计平均///

    doubletemp1=0, temp2=0;

    for(i=0;i《num;i++)

    {

    temp1+=Index[i];

    temp2+=R[i];

    }

    //计算各次结果的统计平均

    M_Index=(double)temp1/num;

    M_R=(double)temp2/num;

    cout《《“//”《《endl;

    cout《《num《《“次运行,平均聚类正确率: ”《《100*M_R《《“%”《《endl;

    //输出精度为小数点后6位

    cout.precision(6);

    //固定格式

    cout.setf(ios::fixed);

    cout《《“平均目标函数:”《《M_Index《《endl;

    //统计结果文件保存

    ofstreamresultfile(“聚类结果.txt”,ios::app);

    resultfile《《“//”《《endl;

    resultfile《《num《《“次运行,平均聚类正确率: ”《《100*M_R《《“%”《《endl;

    //输出精度为小数点后6位

    resultfile.precision(6);

    //固定格式

    resultfile.setf(ios::fixed);

    resultfile《《“平均目标函数:”《《M_Index《《endl;

    return0;

    }

    展开全文
  • C均值聚类法,MATLAB

    2017-04-16 18:50:26
    采用C均值聚类算法对男女生样本数据中的身高、体重2个特征进行聚类分析,考察不同的类别初始值以及类别数对聚类结果的影响,并以友好的方式图示化结果。
  • 模糊C均值聚类,模糊c均值聚类算法的优缺点,matlab源码
  • 聚类分析是多元统计分析的一种,也是无监督模式识别的一个重要分支,在模式分类 图像处理和模糊规则处理等众多领域中获得最广泛的应用。它把一个没有类别标记的样本按照某种准则划分为若干子集,使相似的样本尽可能...
  • 模糊C均值聚类图像分割算法matlab实现模糊C均值聚类图像分割算法matlab实现模糊C均值聚类图像分割算法matlab实现
  • 模糊C均值聚类算法实现数据挖掘的matlab源代码
  • matlab实现模糊c均值聚类

    热门讨论 2009-06-04 00:35:21
    matlab中实现模糊c均值聚类,含聚类坐标和分类数目,源程序和运行结果,程序易于修改
  • 模糊C均值聚类(FCM),模糊c均值聚类算法的优缺点,matlab源码.zip

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 939
精华内容 375
关键字:

模糊c均值聚类matlab

matlab 订阅