三维点云学习（3）7- 实现GMM

最新推荐文章于 2024-05-12 23:46:48 发布
最新推荐文章于 2024-05-12 23:46:48 发布
阅读量651 收藏 6
点赞数
分类专栏： 点云处理 深蓝点云处理课程笔记 文章标签： 聚类 python
原文链接：https://blog.csdn.net/weixin_41281151/article/details/107440893
版权

三维点云学习（3）7- 实现GMM

github大神参考代码
高斯混合模型的通俗理解
GMM课程个人总结笔记

最终效果图

原图
在这里插入图片描述
进行高斯聚类后的图
在这里插入图片描述

代码编写流程

1.输入数据集x1 x2 …xn,和K，初始化三个高斯模型的未知数
2.E-step 算出后验概率 --一个点属于哪个类的概率
3.M-step 算出高斯模型三个参数
在这里插入图片描述
在这里插入图片描述

核心编码

K-means为上一章写得KMeans.py代码,放置到统一目录下即可调用

#GMM.py
class GMM(object):
    # maxiter  最大迭代次数为50次
    def init(self, n_clusters, max_iter=1):
        self.n_clusters = n_clusters
        self.max_iter = max_iter
        self.k = n_clusters

        self.mu = None            #mean
        self.cov = None           #协方差矩阵
        self.prior = None         #先验概率 -> 权重
        self.posteriori = None   #后验概率       # kN矩阵

聚类流程
1.初始化
类的个数：k=3；
协方差矩阵 cov为三个 22的单位矩阵；
后验概率 pi 为 1/k （全概率/类的个数）；
mean 为K-Means选取的center点

2.E-step 算出后验概率 --一个点属于哪个类的概率

3.M-step 算出高斯模型三个参数

4.step2 step3 往复迭代 

        def fit(self, data):
        # 作业3
        # 屏蔽开始
        # step1 初始化 Mu pi cov
        ##init Mu ，使用K-means中心点
        k_means = KMeans.K_Means(n_clusters=self.k)
        k_means.fit(data)
        self.mu = np.asarray(k_means.centers_)   # 将mean的初始值为 k-means 的中心点   3*2 矩阵
        self.cov = np.asarray([eye(2,2)]*self.k)                      #初始化的cov为 3*2*2 的单位矩阵
        self.prior = np.asarray([1/self.k ]*self.k).reshape(3,1)                          #对pi进行均等分  3*1 矩阵
        self.posteriori = np.zeros((self.k,len(data)))                                    #初始化 后验概率为 K*N的 矩阵
        for _ in range(self.max_iter):   #迭代
            #step2 E-step 算出后验概率posteriori --一个点属于哪个类的概率
            for k in range(self.k):
                self.posteriori[k] = multivariate_normal.pdf(x=data,mean=self.mu[k],cov=self.cov[k])    #提取每个点的概率密度分布
            self.posteriori = np.dot(diag(self.prior.ravel()),self.posteriori)                                  #diag 将一维数组元素放在对角线上，方便进行对应的数据乘法运算 变为3*3对角矩阵 3*3 * 3*N = 3*N,ravel 将矩阵里所有元素变为列表
            ##归一化
            self.posteriori /= np.sum(self.posteriori,axis=0)   #后验概率,3*N矩阵
            #step3 M-step 使用MLE 算出高斯模型三个参数  mu:mean cov：协方差  prior：先验概率
            self.Nk = np.sum(self.posteriori,axis=1)
            self.mu = np.asarray([np.dot(self.posteriori[k],data) / self.Nk[k] for k in range(self.k)])        #self.posteriori[k]: 3*2  data:n*2  self.Nk[k]:1
            self.cov = np.asarray([np.dot((data-self.mu[k]).T, np.dot(np.diag(self.posteriori[k].ravel()),data-self.mu[k])) / self.Nk[k] for k in range(self.k)])   #sel.cov : 3*2*2
            self.prior = np.asarray([self.Nk / self.k]).reshape(3,1)               #self.prior  3*1
        self.fitted = True

个人心得

1.用好numpy进行矩阵运算，可以大大节省算法运算时间和提高效率
2.初始值的选取，看过大神的代码，初始值。mean选取的是K-means后的中心点，pi 初始化时 K-means后每个类在整体中所占据的比例，方差 K-means类中点的协方差矩阵，后验概率是经过前三值得计算后结果，初始中心点得选取尽可能之间分布较远，有利于聚类更快得收敛
3.理清楚矩阵之间得运算，多print shape
4.用好numpy！！！

完整代码

python实现K-means

# 文件功能：实现 GMM 算法

import numpy as np
from numpy import *
import pylab
import random, math

import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse
from scipy.stats import multivariate_normal
import KMeans

plt.style.use('seaborn')


class GMM(object):
    # max_iter  最大迭代次数为50次
    def __init__(self, n_clusters, max_iter=50):
        self.n_clusters = n_clusters
        self.max_iter = max_iter
        self.k = n_clusters

        self.mu = None            #mean
        self.cov = None           #协方差矩阵
        self.prior = None         #先验概率 -> 权重
        self.posteriori = None   #后验概率       # k*N矩阵

    def fit(self, data):
        # 作业3
        # 屏蔽开始
        # step1 初始化 Mu pi cov
        ##init Mu ，使用K-means中心点
        k_means = KMeans.K_Means(n_clusters=self.k)
        k_means.fit(data)
        self.mu = np.asarray(k_means.centers_)   # 将mean的初始值为 k-means 的中心点   3*2 矩阵
        self.cov = np.asarray([eye(2,2)]*self.k)                      #初始化的cov为 3*2*2 的单位矩阵
        self.prior = np.asarray([1/self.k ]*self.k).reshape(3,1)                          #对pi进行均等分  3*1 矩阵
        self.posteriori = np.zeros((self.k,len(data)))                                    #初始化 后验概率为 K*N的 矩阵
        for _ in range(self.max_iter):   #迭代
            #step2 E-step 算出后验概率posteriori --一个点属于哪个类的概率
            for k in range(self.k):
                self.posteriori[k] = multivariate_normal.pdf(x=data,mean=self.mu[k],cov=self.cov[k])    #提取每个点的概率密度分布
            self.posteriori = np.dot(diag(self.prior.ravel()),self.posteriori)                                  #diag 将一维数组元素放在对角线上，方便进行对应的数据乘法运算 变为3*3对角矩阵 3*3 * 3*N = 3*N,ravel 将矩阵里所有元素变为列表
            ##归一化
            self.posteriori /= np.sum(self.posteriori,axis=0)   #后验概率,3*N矩阵
            #step3 M-step 使用MLE 算出高斯模型三个参数  mu:mean cov：协方差  prior：先验概率
            self.Nk = np.sum(self.posteriori,axis=1)
            self.mu = np.asarray([np.dot(self.posteriori[k],data) / self.Nk[k] for k in range(self.k)])        #self.posteriori[k]: 3*2  data:n*2  self.Nk[k]:1
            self.cov = np.asarray([np.dot((data-self.mu[k]).T, np.dot(np.diag(self.posteriori[k].ravel()),data-self.mu[k])) / self.Nk[k] for k in range(self.k)])   #sel.cov : 3*2*2
            self.prior = np.asarray([self.Nk / self.k]).reshape(3,1)               #self.prior  3*1
        self.fitted = True

        # 屏蔽结束
    #计算每个点的类别
    def predict(self, data):
        # 屏蔽开始
        result = []
        if not self.fitted:
            print('Unfitter. ')
            return result
        result = np.argmax(self.posteriori,axis=0)    #比较每个点的后验概率
        return result

        # 屏蔽结束


# 生成仿真数据
def generate_X(true_Mu, true_Var):
    # 第一簇的数据
    num1, mu1, var1 = 400, true_Mu[0], true_Var[0]
    X1 = np.random.multivariate_normal(mu1, np.diag(var1), num1)
    # 第二簇的数据
    num2, mu2, var2 = 600, true_Mu[1], true_Var[1]
    X2 = np.random.multivariate_normal(mu2, np.diag(var2), num2)
    # 第三簇的数据
    num3, mu3, var3 = 1000, true_Mu[2], true_Var[2]
    X3 = np.random.multivariate_normal(mu3, np.diag(var3), num3)
    # 合并在一起
    X = np.vstack((X1, X2, X3))
    # 显示数据
    plt.figure(figsize=(10, 8))
    plt.axis([-10, 15, -5, 15])
    plt.scatter(X1[:, 0], X1[:, 1], s=5)
    plt.scatter(X2[:, 0], X2[:, 1], s=5)
    plt.scatter(X3[:, 0], X3[:, 1], s=5)
    plt.show()
    return X


def points_show(point,color):
    x = []
    y = []
    point = np.asarray(point)
    for i in range(len(point)):
        x.append(point[i][0])
        y.append(point[i][1])
    plt.scatter(x, y,color=color)
    #plt.show()



if __name__ == '__main__':
    # 生成数据
    true_Mu = [[0.5, 0.5], [5.5, 2.5], [1, 7]]
    true_Var = [[1, 3], [2, 2], [6, 2]]
    X = generate_X(true_Mu, true_Var)

    gmm = GMM(n_clusters=3)
    gmm.fit(X)  # 确定中心点的位置
    cat = gmm.predict(X)  # 提取点的索引
    K = 3

    # visualize:
    color = ['red', 'blue', 'green', 'cyan', 'magenta']
    labels = [f'Cluster{k:02d}' for k in range(K)]

    cluster = [[] for i in range(K)]  # 用于分类所有数据点
    for i in range(len(X)):
        if cat[i] == 0:
            cluster[0].append(X[i])
        elif cat[i] == 1:
            cluster[1].append(X[i])
        elif cat[i] == 2:
            cluster[2].append(X[i])

    points_show(cluster[0], color="red")
    points_show(cluster[1], color="blue")
    points_show(cluster[2], color="yellow")
    plt.show()
    # for k in range(K):
    #     plt.scatter(X[cat == k][:, 0], X[cat == k][:, 1], c=color[k], label=labels[k])
    #
    # mu = gmm.mu
    # plt.scatter(mu[:, 0], mu[:, 1], s=300, c='grey', marker='P', label='Centroids')
    #
    # plt.xlabel('X')
    # plt.ylabel('Y')
    # plt.legend()     #显示图例
    # plt.title('GMM Testcase')
    # plt.show()

 

selfDisciplineSun
关注
专栏目录
三维点云处理(6)——Model Fitting
weixin_44554973的博客
07-04 642
Model FittingLeast SquareLoss functionsNon-Linear LSQHough TransformRandom Sample Consensus (RANSAC) Least Square Definition of “fit” – minimize the perpendicular distance: E=∑i=1n(axi+byi+c)2 E=\sum^n_{i=1}(ax_i+by_i+c)^2 E=i=1∑n​(axi​+byi​+c)2 The soluti
【学习笔记】深蓝学院-三维点云处理
麒麒哈尔的博客
07-09 7149
文章目录PCA & Kernel PCASuface Normal & Filters PCA & Kernel PCA Kernel PCA可以理解为，先通过非线性变换，将点云投影到高维空间中，然后在高维空间中做PCA。但这个非线性变换函数很难找，所以通过数学变换，改写，用核方法表示。使用常用的，多项式的核，高斯的核就可以实现Kernel PCA。 Suface Normal & Filters Surface Normal就是PCA中中最后一维的向量，将点云做PCA，最后
三维点云学习（3）7- 实现GMM
weixin_41281151的博客
07-19 1630
三维点云学习（3）7- 实现GMM github大神参考代码 高斯混合模型的通俗理解 GMM课程个人总结笔记 最终效果图 原图 进行高斯聚类后的图 代码编写流程 1.输入数据集x1 x2 …xn,和K，初始化三个高斯模型的未知数 2.E-step 算出后验概率 --一个点属于哪个类的概率 3.M-step 算出高斯模型三个参数 核心编码 K-means为上一章写得KMeans.py代码,放置到统一目录下即可调用 #GMM.py class GMM(object): # max_iter
(二) 三维点云课程---GMM
qq_45369294的博客
10-25 1096
三维点云课程—GMM 三维点云课程---GMM三维点云课程---GMM1.前言2.GMM原理2.1E步推导2.2.M步推导2.2.1固定πk,Σk\pi_k,\Sigma_kπk​,Σk​,求解μk\mu_kμk​2.2.2固定πk,μk\pi_k,\mu_kπk​,μk​,求解Σk\Sigma_kΣk​2.2.3固定μk,Σk\mu_k,\Sigma_kμk​,Σk​，求解πk\pi_kπk​3.GMM总结4.GMM完整代码5.GMM的一些缺点 由于KMeans缺乏不确定性的指标，GMM算法可以解决这个问
三维点云学习（3）3-Gaussian Mixture Model (GMM)
weixin_41281151的博客
07-15 1985
三维点云学习（3）3-Gaussian Mixture Model (GMM) 高斯模型 二维高斯分布（Two-dimensional Gaussian distribution）的参数分析 一维高斯模型 二维高斯模型 GMM Σ????：方差 ????k：高斯模型得中心 ????k：每个不同的高斯模型占据的权重 本质： 若干个高斯模型进行线性组合 都需要人工给定K Zk:每个数据点属于第k类，表达为ZK=1 P(Z)先验分布：含义点属于哪个高斯模型的概率 P(Z|X)为后验概率，含
高斯混合聚类(GMM)及代码实现
weixin_34283445的博客
03-22 913
高斯混合聚类(GMM)及代码实现 by 2017-03-20 郭昱良 机器学习算法与Python学习 通过学习概率密度函数的Gaussian Mixture Model (GMM) 与 k-means 类似，不过 GMM 除了用在 clustering 上之外，还经常被用于 density estimation。对于二者的区别而言简单地说，k-means 的结果是每个数据点被 assign 到其中...
C-----GMM高斯混合模型_高斯_rod2j3_GMM_聚类_点云聚类_
09-30
在点云聚类问题中，GMM能够有效地对三维空间中的点进行分类，找出具有相似属性的点组，即聚类。 点云数据通常由激光雷达、3D扫描仪等设备生成，它包含大量的三维坐标点，这些点可以代表物体表面的每一个采样位置。...
三维点云处理kmeans聚类算法python实现
04-27
下面我们将深入探讨三维点云处理中的KMeans聚类算法及其Python实现。 首先，让我们了解三维点云。点云是由空间中多个点组成的集合，每个点包含X、Y、Z坐标，可能还包含颜色、法线等附加信息。在处理这些数据时，...
课程笔记-三维点云处理03 ——Clustering聚类
Jason_____Wang的博客
03-18 1441
课程笔记-三维点云处理03 ——Clustering聚类 本系列笔记是对深蓝学院所开设的课程：《三维点云处理》的笔记 课程每周更新，我也会努力将每周的知识点进行总结，并且整理成笔记发上来，欢迎各位多多交流&批评指正！！ 本文主要为课程第三章的笔记！ 课程链接： 三维点云处理——深蓝学院 目录 正式内容: #################################################### ...
Python实现K-means算法在三维点云聚类中的应用
在三维点云聚类中，GMM可以用来估计和模拟数据点的分布，从而实现对数据的分组。 - KMeans.py：顾名思义，该文件将包含k-means聚类算法的实现代码。k-means算法通过迭代优化过程寻找数据点的聚类中心，使得每个数据...
GMM:C ++实现GMM（高斯混合模型）
04-27
GMM C ++实现GMM（高斯混合模型） 中文详细信息： :
高斯混合模型的Python实现和可视化
05-28
用Python实现了GMM算法，解决了协方差的行列式为0的问题，用K均值算法进行初始化，对结果进行了可视化，博客地址：http://blog.csdn.net/u012176591/article/details/46051431
三维协方差矩阵实验.c
11-27
通过C语言实现三维协方差矩阵运算，包含例程，调用函数传相应参数就可以了，需要显示协方差矩阵可自行编写代码遍历数组
三维点云学习（3）8- 实现Spectral谱聚类
Sun的博客
02-21 987
三维点云学习（3）8- 实现Spectral谱聚类 谱聚类代码参考课堂谱聚类理论笔记 效果图 原图 效果图 前三种为自写的聚类算法，分别是 KMeans、GMM、Spectral,后面为sklearn自带的聚类算法库 步骤： step1 先计算每个点的距离矩阵，再使用Kd-tree建立近邻矩阵 如下分别为两种建立关系矩阵的办法 #step1 先计算每个点的距离矩阵，再使用KNN建立近邻矩阵 self.W = kdtreecontribute_Matrix(d
GMM高斯混合模型的EM算法参数估计matlab仿真
fpga/matlab/simulink算法仿真工程
03-01 1439
最大期望算法（Expectation-Maximization algorithm, EM），或Dempster-Laird-Rubin算法 ，是一类通过迭代进行极大似然估计（Maximum Likelihood Estimation, MLE）的优化算法，通常作为牛顿迭代法（Newton-Raphson method）的替代用于对包含隐变量（latent variable）或缺失数据（incomplete-data）的概率模型进行参数估计。高斯混合模型可用于聚类，这是将一组数据点分组为聚类的任务。
高斯混合模型（Gaussian Mixture Model，GMM）聚类算法（python实现）
最新发布
zwy123987的博客
05-12 2052
高斯混合模型（Gaussian Mixture Model，GMM）是一种基于概率模型的聚类方法，它假设数据是由多个高斯分布组成的混合体。以下是 GMM 聚类算法的基本原理和数学公式。
三维点云处理第三章（3）--GMM（高斯混合模型）
qq_53372894的博客
07-09 920
混合高斯模型就是把每一个类都用一个高斯分布来描述。K-Means对每一个类是没有建模的，它只是给一个中心点，GMM进一步的用高斯模型来描绘这个类里面的数据。也就是说，现在每一个类是一个概率模型，也就可以给出每一个点属于哪一个类的概率。
GMM 高斯混合模型 聚类 Python实现
热门推荐
csdn_inside的博客
12-26 1万+
原理也不多说了。。大致思路就是把数据建立成k个高斯分布，EM迭代N次。最后看每个点在哪个高斯分布的概率最高，就分到那个分布。 这里的computeGamma函数，用来算第i个簇的后验概率γji，用了2层循环，效率不高，本来想向量化的，搞了半天没搞出来。。干脆就先循环吧。。包括后面的fit方法也是一样。。用了很多循环。 X的shape是(n_samples,n_features) mu的sha...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值