精华内容
下载资源
问答
  • 2021-04-21 01:44:17

    算法特点

    GMM聚类与Keams聚类很相似。K-means是将每个数据点分配到某一个类别中,而GMM则是给出这些数据点被分配到每个类别的概率,又叫做soft assignment。其除了被用在clustering上,还经常被用于density estimation上。

    得出一个概率有很多的好处,因为它的信息量比简单的一个结果要多。这个概率可以被看做是得出这个结果的把握。比如说,在诸如疾病诊断时,算法得出49%的概率患病,为51%的概率正常,如果仅仅用50%的阈值将患者诊断为“正常”的话,风险是非常大的,也就是说得出正常的结果的把握是非常小的。这个情况下,就会拒绝发表评论,而把这个任务留给有经验的医生去解决。

    学习的过程可以看做是一种“归纳”的过程,在归纳的时候需要有一个提前假设,即“归纳偏置”。比如说线性回归,它的归纳偏执就是“数据是符合线性函数的,满足要求的函数必须是线性函数”。如果去掉“线性函数”这个归纳偏执,那么就会产生过拟合的问题,我们就可以构造n-1次多项式函数,让它完美的穿过所有的N的点,甚至可以构造出无数个满足条件的函数。然而,我们学习的目的通常不是解释现有的事物,而是从中归纳知识,并且能够应用到新的事物上。

    没有归纳偏执或者归纳偏执太宽泛会导致过拟合,而限制过大的归纳偏执也是有问题的;比如说,如果数据不是非线性分布的,强行的使用非线性函数去做分类通常并不能够得到好的结果。难点就是在这之间找到一个平衡点。

    混合高斯模型的归纳偏执很明显,就是假设数据符合混合高斯分布,也就是看作数据是从多个高斯分布中生成而来。混合模型其实是可以变的任意复杂的,通过增加模型的个数,我们可以任意的逼近任何连续的概率密度分布。

    主程序:

    clear;

    clc;

    %从实验结果可以看出先使用Keams方法计算初始点,再使用GMM进行聚类得到的结果

    %明显优于直接使用GMM方法进行聚类得到的结果

    %数据X1和X2的真实均值为[1,1;4,4;8,1]

    %协方差矩阵均为[2,0;0,2];

    %数据集X1的混合系数为[1/3,1/3,1/3]

    %数据集X2的混合系数为[0.6,0.3,0.1]

    [X1,X2]=generateData();

    K=3;

    %数据集X1

    [a_init,mu_init,sigma_init]=initPara(X1);

    [a_GMM,mu_GMM,sigma_GMM]=GMM(X1,a_init,mu_init,sigma_init);

    [centroids,~] = Kmeans( X1,mu_init,K);

    disp('1.Keams算法执行后数据集X1的均值为:')

    disp(centroids);

    disp('2.GMM后高斯混合模型数据集X1的均值,协方差矩阵为:');

    disp('均值为:');

    disp(mu_GMM);

    disp('协方差矩阵为:')

    disp(sigma_GMM);

    disp(['混合系数为:',num2str(a_GMM)]);

    [a_Kea_GMM,mu_Kea_GMM,sigma_Kea_GMM]=GMM(X1,a_init,centroids,sigma_init);

    disp('3.使用Keams计算初始均值再使用GMM进行聚类后的数据集X1的均值,协方差矩阵为:');

    disp('均值为:');

    disp(mu_Kea_GMM);

    disp('协方差矩阵为:')

    disp(sigma_Kea_GMM);

    disp(['混合系数为:',num2str(a_Kea_GMM)]);

    %数据集X2

    [a_init,mu_init,sigma_init]=initPara(X2);

    [a_fin,mu_fin,sigma_GMM]=GMM(X2,a_init,mu_init,sigma_init);

    [centroids,~] = Kmeans( X2,mu_init,K);

    disp('1.Keams算法执行后数据集X2的均值为:')

    disp(centroids);

    disp('2.GMM后高斯混合模型数据集X2的均值,协方差矩阵为:');

    disp('均值为:');

    disp(mu_GMM);

    disp('协方差矩阵为:')

    disp(sigma_GMM);

    disp(['混合系数为:',num2str(a_GMM)]);

    [a_Kea_GMM,mu_Kea_GMM,sigma_Kea_GMM]=GMM(X2,a_init,centroids,sigma_init);

    disp('3.使用Keams计算初始均值再使用GMM进行聚类后的数据集X2的均值,协方差矩阵为:');

    disp('均值为:');

    disp(mu_Kea_GMM);

    disp('协方差矩阵为:')

    disp(sigma_Kea_GMM);

    disp(['混合系数为:',num2str(a_Kea_GMM)]);

    首先根据均值协方差矩阵混合系数生成高斯混合分布数据:

    function [X1,X2]=generateData()

    mu=[1,1;4,4;8,1];

    sigma=[2,0;0,2];

    a1=[1/3,1/3,1/3];

    a2=[0.6,0.3,0.1];

    N=1000;

    rand1=randsrc(N,1,[[1,2,3];a1]);

    rand2=randsrc(N,1,[[1,2,3];a2]);

    X1=[];

    X2=[];

    mean1=[];

    for i=1:size(a1,2)

    X1_temp=mvnrnd(mu(i,:),sigma,length(find(rand1==i)));

    X1=[X1;X1_temp];

    subplot(1,2,1);

    plot(X1_temp(:,1),X1_temp(:,2),'+');

    title('X1');

    legend('模型1','模型2','模型3');

    xlabel('x');ylabel('y');

    hold on;

    mean1=[mean1;mean(X1_temp)];

    cov1(:,:,i)=cov(X1_temp);

    X2_temp=mvnrnd(mu(i,:),sigma,length(find(rand2==i)));

    X2=[X2;X2_temp];

    subplot(1,2,2);

    plot(X2_temp(:,1),X2_temp(:,2),'*');

    title('X2');

    legend('模型1','模型2','模型3');

    xlabel('x');ylabel('y');

    hold on;

    end

    disp(['直接使用数据集X1来估计的属于三个模型随机矢量的均值分别为:']);

    disp(mean1);

    disp(['直接使用数据集X1来的属于三个模型随机矢量的协方差矩阵分别为:']);

    disp(cov1);

    end

    初始化参数:

    function [ a,mu,sigma ] = initPara(X)

    [m,n]=size(X);

    r=randperm(m);

    mu=X(r(1:3),:);

    a=[1/3,1/3,1/3];

    sigma=[1,0;0,1];

    end

    GMM算法:

    function [a_fin,mu_fin,sigma_fin]=GMM(X1,a_init,mu_init,sigma_init)

    %UNTITLED2 此处显示有关此函数的摘要

    % 此处显示详细说明

    K=size(a_init,2);

    [M,N]=size(X1);

    a=a_init;

    mu=mu_init;

    sigma=sigma_init;

    px=zeros(M,K);

    thre=1e-5;

    LLD_pro=inf;

    while true

    for i=1:K

    px(:,i)=mvnpdf(X1,mu(i,:),sigma);

    end

    pGramm=repmat(a,M,1).*px;

    pGramm=pGramm./repmat(sum(pGramm,2),1,K);

    Nk=sum(pGramm,1); %1*K

    mu=diag(1./Nk)*pGramm'*X1;

    for kk=1:K

    Xshift=X1-repmat(mu(kk,:),M,1);

    sigma(:,:,kk)=(Xshift'*diag(pGramm(:,kk))*Xshift)/Nk(:,kk);

    end

    a=Nk/M;

    LLD=sum(log(a*px'));

    if (LLD-LLD_pro)

    break;

    end

    LLD_pro=LLD;

    end

    a_fin=a;

    mu_fin=mu;

    sigma_fin=sigma;

    end

    Keams:

    function [ centroids,centroidsIndex ] = Kmeans( X,mu_init,K)

    centroids=mu_init;

    thre=1e-5;

    while true

    pro_centroids=centroids;

    [centroidsIndex]=findCloestCentroids(X,centroids,K);

    [centroids]=computeCentroids(centroidsIndex,X,K);

    if norm(centroids-pro_centroids)

    break;

    end

    end

    function [centroidsIndex]=findCloestCentroids(X,centroids,K)

    [M,~]=size(X);

    distMat=zeros(M,K);

    centroidsIndex=zeros(M,1);

    for i=1:M

    for j=1:K

    distMat(i,j)=norm(X(i,:)-centroids(j,:));

    end

    centroidsIndex(i,:)=find(distMat(i,:)==min(distMat(i,:)));

    end

    end

    function [centroids]=computeCentroids(centroidsIndex,X,K)

    [M,N]=size(X);

    centroids=zeros(K,N);

    for i=1:K

    centroidsNum=sum(centroidsIndex==i);

    centroids(i,:)=sum(X(centroidsIndex==i,:))./centroidsNum;

    end

    end

    算法问题

    GMM和K-means有同样的问题,如果初始值选择的不好,那么可能会得到局部最优解,得不到全局最优解。我们可以先使用K-means方法得到的结果作为初始值传给GMM模型,再使用GMM进行细致迭代。 GMM本身只是一个模型,EM算法并不是唯一的求解方法。

    更多相关内容
  • 基于python的高斯混合模型(GMM 聚类)的 EM 算法实现
  • GMM/ k-mean 聚类算法
  • 代码已跑通,欢迎下载,欢迎交流
  • 基于集成GMM聚类的少标记样本图像分类.pdf
  • 这段代码实现了基本的GMM算法,支持全值或仅对角非零值的多个协方差矩阵,其计算速度使用C/C++和多线程进行了优化。 当样本数量和特征维度很大时,这段代码会比 Matlab 工具箱中的代码快很多例如,对于17维76800个...
  • GMM聚类

    2021-04-13 19:15:20
    GMM聚类 高斯分布 GMM 一、参数初始化 # GMM 参数初始化 # dataset: [N,D] # K : cluster的个数(高斯成分的个数) def init_GMM(dataset,K): N,D = np.shape(dataset) val_max = np.max(dataset,axis=0) val_...

    GMM聚类

    高斯分布

    在这里插入图片描述

    GMM

    在这里插入图片描述

    一、参数初始化

    # GMM 参数初始化
    # dataset: [N,D]
    # K : cluster的个数(高斯成分的个数)
    def init_GMM(dataset,K):
        N,D = np.shape(dataset)
        val_max = np.max(dataset,axis=0)
        val_min = np.min(dataset,axis=0)   
        centers = np.linspace(val_min,val_max,num=K+2) 
        mus = centers[1:-1,:]   
        sigmas = np.array([0.5*np.eye(D) for i in range(K)])  
        ws = 1.0/K * np.ones(K)
        
        return mus,sigmas,ws     # (K, D) (K, D, D) (K,)
    

    二、计算 N(X;m,Σ)

    在这里插入图片描述

    # 计算一个高斯pdf
    # x(dataset): 数据[N,D]
    # sigma 方差[D,D]
    # mu 均值[1,D] ;注意这里的mu是数据的均值(不是mus)    
    def getPdf(x,mu,sigma,eps=1e-12):
        N,D = np.shape(x)
        
        if D==1:
            sigma = sigma+eps
            A = 1.0 / (sigma)
            det = np.fabs(sigma[0])
        else:
            sigma = sigma + eps*np.eye(D)
            A = np.linalg.inv(sigma)    # np.linalg.inv()这里矩阵求逆
            det = np.fabs(np.linalg.det(sigma)) # np.linalg.det()矩阵求行列式
            
        # 计算系数
        factor = (2.0 * np.pi)**(D / 2.0) * (det)**(0.5)
        
        # 计算 pdf
        dx = x - mu
        pdf = [(np.exp(-0.5*np.dot(np.dot(dx[i],A),dx[i]))+eps)/ factor for i in range(N)]
        
        return pdf      
    

    三、更新参数

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

    def train_GMM_step(dataset,mus,sigmas,ws):
        N,D = np.shape(dataset)
        K,D = np.shape(mus)
        # 计算样本在每个Cluster上的Pdf
        pdfs = np.zeros([N,K])
        for k in range(K):      # 这里算出N(x;m...)
            pdfs[:,k] = getPdf(dataset,mus[k],sigmas[k])
        
        # 获取r
        r = pdfs*np.tile(ws,(N,1))     
        r_sum = np.tile(np.sum(r,axis=1,keepdims=True),(1,K))  
        r = r/r_sum                    # 这里为R ik
        
        # 进行参数更新
        for k in range(K):
            r_k = r[:,k]               # r_k.shape=(N,)
            N_k = np.sum(r_k)
            r_k = r_k[:,np.newaxis]    # r_k.shape=(N,1)
            
            # 更新mu
            mu = np.sum(dataset*r_k,axis=0)/N_k   #[D,1]
            
            # 更新sigma
            dx = dataset - mu
            sigma = np.zeros([D,D])
            for i in range(N):
                sigma = sigma + r_k[i,0]*np.outer(dx[i],dx[i])  # np.outer用来求矩阵外积
            sigma = sigma/N_k
            
            # 更新w
            w = N_k/N
            mus[k] = mu
            sigmas[k] = sigma
            ws[k] = w
        
        return mus,sigmas,ws        # (K, D) (K, D, D) (K,)
    

    四、GMM训练

    # GMM训练
    def train_GMM(dataset,K,m=10):
        mus,sigmas,ws = init_GMM(dataset,K)
        # print(mus,sigmas,ws)
        for i in range(m):
            # print("step: ",i)
            mus,sigmas,ws = train_GMM_step(dataset,mus,sigmas,ws)
            # print(mus,sigmas,ws)
        return mus,sigmas,ws
    

    五、计算数据在每个模型上的似然值

    def getlogPdfFromeGMM(dataset,mus,sigmas,ws):
        N,D = np.shape(dataset)
        K,D = np.shape(mus)
        
        weightedlogPdf = np.zeros([N,K])
        
        for k in range(K):    
            temp = getPdf(dataset,mus[k],sigmas[k],eps = 1e-12)  
            weightedlogPdf[:,k] = np.log(temp) + np.log(ws[k])  # 这里为公式log(w*N())
            
        return weightedlogPdf, np.sum(weightedlogPdf,axis=1)
    

    六、利用GMM进行聚类(通过比较似然值)

    def clusterByGMM(datas,mus,sigmas,ws):
        weightedlogPdf,_ = getlogPdfFromeGMM(datas,mus,sigmas,ws)
        labs = np.argmax(weightedlogPdf,axis=1)
        return labs  # 得到分类标签
    
    测试:
    # 作图
    def draw_cluster(dataset,lab,dic_colors):
        plt.cla()
        vals_lab = set(lab.tolist())
        
        for i,val in enumerate(vals_lab):
            index = np.where(lab==val)[0]
            sub_dataset = dataset[index,:]
            plt.scatter(sub_dataset[:,0],sub_dataset[:,1],s=16.,color=dic_colors[i])
    
    # GMM聚类测试
    dic_colors = {0:(0.,0.5,0.),1:(0.8,0,0),2:(0.5,0.5,0),3:(0.5,0.5,0.9)}
    a = np.random.multivariate_normal([2,2],[[.5,0],[0,.5]],200)
    b = np.random.multivariate_normal([0,1],[[.5,0],[0,.5]],200)
    c = np.random.multivariate_normal([1,4],[[.5,0],[0,.5]],200)
    d = np.random.multivariate_normal([4,4],[[.5,0],[0,.5]],200)
    dataset = np.r_[a,b,c,d]
    # print(dataset.shape)
    
    # 真实标签
    lab_true = np.r_[np.zeros(200),np.ones(200),2*np.ones(200),3*np.ones(200)].astype(int)
    
    # 绘制原始数据散点图
    draw_cluster(dataset,lab_true,dic_colors)
    
    原始数据

    原始数据

    # 训练GMM
    mus,sigmas,ws = train_GMM(dataset,K=4,m=10)
    #print(mus,sigmas,ws)
    
    # 进行聚类
    labs_GMM = clusterByGMM(dataset,mus,sigmas,ws)
    #print(labs_GMM)
    
    # 绘制聚类后图片
    draw_cluster(dataset,labs_GMM,dic_colors)
    
    GMM聚类效果

    聚类效果

    GMM与K-means比较

    原始数据

    原始数据

    K-means聚类效果

    K-means聚类效果

    GMM聚类效果

    GMM聚类效果

    展开全文
  • 基于GMM聚类方法构建经验模型的机载实时模型改进方法.pdf
  • gmm聚类的matlab实现

    2012-10-10 12:14:15
    GMM算法的实现,运行文件gmmclassfile.m,其中的数据用数据文件表示,在gmmclassfile.m中的filename改为需要聚类的数据文件,.data形式的。绝对可用
  • 针对传统基于物品的推荐算法由于数据稀疏性导致的低推荐精度问题,提出了一种融合GMM聚类和FOA-GRNN模型的推荐算法。该算法首先使用高斯混合模型(GMM)方法对物品特征进行聚类;然后根据聚类结果分别构造评分矩阵,...
  • 点云学习03-GMM聚类

    2021-11-07 21:51:38
    1. GMM 公式推导 2. 代码详解 E-Step # E-step p_gama = self.compute_p_gama(temp_mu, temp_var, temp_pi, data) 其中: def compute_p_gama(self, mu_s, var_s, pi_s, data): p_gama = np.zeros((data....

    1. GMM 公式推导

    E-step
    M-Step

    2. 代码详解

    1. E-Step
    # E-step 
                   p_gama = self.compute_p_gama(temp_mu, temp_var, temp_pi, data)
    

    其中:

    def compute_p_gama(self, mu_s, var_s, pi_s, data):
           p_gama = np.zeros((data.shape[0], self.n_clusters))
           for idx, cluster in enumerate(zip(mu_s, var_s, pi_s)):
               mu = cluster[0]
               var = cluster[1]
               pi = cluster[2]
               p_gama[:, idx] = pi * self.multi_gauss(mu, var, data)
           return np.array([x / np.sum(x) for x in p_gama]) 
    
    1. M-Step
    # M-step
                   new_mu = np.zeros(temp_mu.shape)
                   for k in range(0, self.n_clusters):
                       N_K = np.sum(p_gama[:,k])
                       N_K_inv = 1.0 / N_K
                       new_mu[k,:] = N_K_inv * np.sum(np.expand_dims(p_gama[:, k], axis=1) * data, axis=0)
                       x_center = data - np.expand_dims(new_mu[k,:], axis=0)
                       temp_var[k,:,:] = N_K_inv * np.dot(x_center.transpose(), np.expand_dims(p_gama[:,k],axis=1)*x_center)
                       temp_pi[k] = N_K / data.shape[0]
    

    更完整的代码见GMM

    结果

    各种方法聚类的结果

    展开全文
  • 以下为GMM聚类程序import pandas as pdimport matplotlib.pyplot as pltimport numpy as npdata=pd.read_csv('Fremont.csv',index_col='Date',parse_dates=True)print(data.head())data.plot()plt.show()data....

    bcf76abef0ccaf91849d7a274d89434d.png

    d36c010199564a18c9bd34df2b4d6dc6.png

    b793e397b7028c138da730688db9fb3f.png

    以下为GMM聚类程序

    import pandas as pd

    import matplotlib.pyplot as plt

    import numpy as np

    data=pd.read_csv('Fremont.csv',index_col='Date',parse_dates=True)

    print(data.head())

    data.plot()

    plt.show()

    data.resample('w').sum().plot()#以周为时间统计

    data.resample('D').sum().rolling(365).sum().plot()

    plt.show()

    ##按照时间为统计

    data.groupby(data.index.time).mean().plot()

    plt.xticks(rotation=45)

    plt.show()

    data.columns=['West','East']

    data['Total']=data['West']+data['East']

    pivoted=data.pivot_table('Total',index=data.index.time,columns=data.index.date)

    pivoted.iloc[:5,:5]

    print(pivoted.iloc[:5,:5])

    pivoted.plot(legend=False,alpha=0.01)

    plt.xticks(rotation=45)

    plt.show()

    print(pivoted.shape)

    X=pivoted.fillna(0).T.values

    print(X.shape)

    from sklearn.decomposition import PCA

    X2 =PCA(2).fit_transform(X)

    print(X2.shape)

    plt.scatter(X2[:,0],X2[:,1])

    plt.show()

    from sklearn.mixture import GaussianMixture

    gmm =GaussianMixture (2)

    gmm.fit(X)

    # labels= gmm.predict_proba(X)

    # print(labels)

    labels=gmm.predict(X)

    print(labels)

    plt.scatter(X2[:,0],X2[:,1],c=labels,cmap='rainbow')

    plt.show()

    from sklearn.datasets.samples_generator import make_blobs

    X,y_true =make_blobs(n_samples=800,centers=4,random_state=11)

    plt.scatter(X[:,0],X[:,1])

    plt.show()

    from sklearn.cluster import KMeans

    KMeans =KMeans(n_clusters=4)

    KMeans.fit(X)

    y_Kmeans=KMeans.predict(X)

    plt.scatter(X[:,0],X[:,1],c=y_Kmeans,s=50,cmap='viridis')

    centers=KMeans.cluster_centers_

    plt.show()

    from sklearn.mixture import GaussianMixture

    gmm =GaussianMixture(n_components=4).fit(X)

    labels=gmm.predict(X)

    print(labels)

    plt.scatter(X[:,0],X[:,1],c=labels,s=40,cmap='viridis')

    plt.show()

    运行结果

    0df2b74e125ae01bdcec4df92a055f13.png

    展开全文
  • GMM聚类模型(高斯混合聚类)

    千次阅读 2019-07-22 20:19:30
    3.GMM聚类模型(高斯混合聚类) k-means聚类模型 非常简单并且易于理解,但是他的简单性也为实际应用带来了挑战。特别是实际应用中,k-means的非概率性和它仅根据到簇中心点的距离来指派将导致性能低下。高斯...
  • 使用多个高斯分布,就可以对数据进行聚类。 单峰的高斯分布作为basis 分布,多个高斯分布使用线性叠加(这种思路类似boost的想法)。 p(x)=∑k=1KπkN(x∣μk,σk2)p(x) = \sum_{k=1}^{K}\pi_k\mathbb{N}(x|\mu_k, \...
  • class AE_layer(nn.Module): def __init__(self,layer_type,n_vis,n_hid,activation=nn.ReLU(),w_init=None): super(AE_layer,self).__init__() encoder_layers = [] #---------------------线性连接的方式-...
  • EM算法之GMM聚类

    2019-01-09 11:37:00
    以下为GMM聚类程序 import pandas as pd import matplotlib.pyplot as plt import numpy as np data=pd.read_csv('Fremont.csv',index_col='Date',parse_dates=True) print(data.head()) data.plot()...
  • 基于GMM 聚类方法构建经验模型的机载实时模型改进方法.pdf
  • gmm的matlab代码gmm聚类 简单可视化如何将EM算法用于高斯混合模型聚类。 您将需要使用matlab来运行代码。 修改datapath变量以使用另一个数据集,并修改变量K更改群集数。 特色作品: 交互式绘图,您可以在其中选择...
  • 对MFCC进行GMM聚类的汉语数字识别方法.pdf
  • 高斯混合模型GMM聚类的步骤和推导

    千次阅读 2020-03-20 15:18:57
      由于最近要做聚类算法方面的内容,看了很多资料,在高斯混合模型(GMM)这里一直没有一个让我完全推导清楚的、理解的文章。经过三天打鱼两天晒网 不懈努力,总算是有一点自己的理解,我希望尽量通俗地把GMM讲明白...
  • 基于GMM聚类的鲁棒性i向量说话人确认.pdf
  • 一种新的α-GMM聚类说话人确认算法.pdf
  • 基于GMM聚类的空调机组多未知模态辨识方法研究.pdf
  • 视频检索中基于GMM聚类的无监督情感场景检测.pdf
  • 基于GMM聚类和SVM的用户负荷行业分类辨识方法.pdf
  • 基于融合GMM聚类与FOA-GRNN模型的推荐算法.pdf
  • 网上很多的代码都是错误的,特别是广为流传的那份,我已经进行了修改,并在此前提下,对群中心距离是否太近进行了判断,如果群中心太近,那就就将两个中心所代表的两个聚类合成为一个聚类,更符合实际
  • k-means、GMM聚类、KNN原理概述

    万次阅读 2017-09-13 09:35:36
    由于工作需要,最近开始弄k-means、KNN、GMM聚类。总结一下这两种聚类方法吧。1. K-means原理:这基本上是最简单也最经典的聚类方法。K是指所要聚的cluster的数量,means是指每一个cluster都有一个中心点(质心),...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,672
精华内容 2,268
关键字:

gmm聚类