图像处理之高斯混合模型

太过爱你忘了你带给我的痛 2022-06-15 06:52 307阅读 0赞

图像处理之高斯混合模型

一：概述

高斯混合模型(GMM)在图像分割、对象识别、视频分析等方面均有应用，对于任意给定的数据样本集合，根据其分布概率， 可以计算每个样本数据向量的概率分布，从而根据概率分布对其进行分类，但是这些概率分布是混合在一起的，要从中分离出单个样本的概率分布就实现了样本数据聚类，而概率分布描述我们可以使用高斯函数实现，这个就是高斯混合模型-GMM。

20170526170138039

20170526170352714

这种方法也称为D-EM即基于距离的期望最大化。

三：算法步骤

1.初始化变量定义-指定的聚类数目K与数据维度D

2.初始化均值、协方差、先验概率分布

3.迭代E-M步骤

- E步计算期望

- M步更新均值、协方差、先验概率分布

-检测是否达到停止条件（最大迭代次数与最小误差满足），达到则退出迭代，否则继续E-M步骤

4.打印最终分类结果

四：代码实现

  1. package com.gloomyfish.image.gmm;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.List;
  7. /**
  8.  * 
  9.  * @author gloomy fish
  10.  *
  11.  */
  12. public class GMMProcessor {
  13.     public final static double MIN_VAR = 1E-10;
  14.     public static double[] samples = new double[]{10, 9, 4, 23, 13, 16, 5, 90, 100, 80, 55, 67, 8, 93, 47, 86, 3};
  15.     private int dimNum;
  16.     private int mixNum;
  17.     private double[] weights;
  18.     private double[][] m_means;
  19.     private double[][] m_vars;
  20.     private double[] m_minVars;
  22.     /***
  23.      * 
  24.      * @param m_dimNum - 每个样本数据的维度， 对于图像每个像素点来说是RGB三个向量
  25.      * @param m_mixNum - 需要分割为几个部分，即高斯混合模型中高斯模型的个数
  26.      */
  27.     public GMMProcessor(int m_dimNum, int m_mixNum) {
  28.         dimNum = m_dimNum;
  29.         mixNum = m_mixNum;
  30.         weights = new double[mixNum];
  31.         m_means = new double[mixNum][dimNum];
  32.         m_vars = new double[mixNum][dimNum];
  33.         m_minVars = new double[dimNum];
  34.     }
  36.     /***
  37.      * data - 需要处理的数据
  38.      * @param data
  39.      */
  40.     public void process(double[] data) {
  41.         int m_maxIterNum = 100;
  42.         double err = 0.001;
  44.         boolean loop = true;
  45.         double iterNum = 0;
  46.         double lastL = 0;
  47.         double currL = 0;
  48.         int unchanged = 0;
  50.         initParameters(data);
  52.         int size = data.length;
  53.         double[] x = new double[dimNum];
  54.         double[][] next_means = new double[mixNum][dimNum];
  55.         double[] next_weights = new double[mixNum];
  56.         double[][] next_vars = new double[mixNum][dimNum];
  57.         List<DataNode> cList = new ArrayList<DataNode>();
  59.         while(loop) {
  60.             Arrays.fill(next_weights, 0);
  61.             cList.clear();
  62.             for(int i=0; i<mixNum; i++) {
  63.                 Arrays.fill(next_means[i], 0);
  64.                 Arrays.fill(next_vars[i], 0);
  65.             }
  67.             lastL = currL;
  68.             currL = 0;
  69.             for (int k = 0; k < size; k++)
  70.             {
  71.                 for(int j=0;j<dimNum;j++)
  72.                     x[j]=data[k*dimNum+j];
  73.                 double p = getProbability(x); // 总的概率密度分布
  74.                 DataNode dn = new DataNode(x);
  75.                 dn.index = k;
  76.                 cList.add(dn);
  77.                 double maxp = 0;
  78.                 for (int j = 0; j < mixNum; j++)
  79.                 {
  80.                     double pj = getProbability(x, j) * weights[j] / p; // 每个分类的概率密度分布百分比
  81.                     if(maxp < pj) {
  82.                         maxp = pj;
  83.                         dn.cindex = j;
  84.                     }
  86.                     next_weights[j] += pj; // 得到后验概率
  88.                     for (int d = 0; d < dimNum; d++)
  89.                     {
  90.                         next_means[j][d] += pj * x[d];
  91.                         next_vars[j][d] += pj* x[d] * x[d];
  92.                     }
  93.                 }
  95.                 currL += (p > 1E-20) ? Math.log10(p) : -20;
  96.             }
  97.             currL /= size;
  99.             // Re-estimation: generate new weight, means and variances.
  100.             for (int j = 0; j < mixNum; j++)
  101.             {
  102.                 weights[j] = next_weights[j] / size;
  104.                 if (weights[j] > 0)
  105.                 {
  106.                     for (int d = 0; d < dimNum; d++)
  107.                     {
  108.                         m_means[j][d] = next_means[j][d] / next_weights[j];
  109.                         m_vars[j][d] = next_vars[j][d] / next_weights[j] - m_means[j][d] * m_means[j][d];
  110.                         if (m_vars[j][d] < m_minVars[d])
  111.                         {
  112.                             m_vars[j][d] = m_minVars[d];
  113.                         }
  114.                     }
  115.                 }
  116.             }
  118.             // Terminal conditions
  119.             iterNum++;
  120.             if (Math.abs(currL - lastL) < err * Math.abs(lastL))
  121.             {
  122.                 unchanged++;
  123.             }
  124.             if (iterNum >= m_maxIterNum || unchanged >= 3)
  125.             {
  126.                 loop = false;
  127.             }
  128.         }
  130.         // print result
  131.         System.out.println("=================最终结果=================");
  132.         for(int i=0; i<mixNum; i++) {
  133.             for(int k=0; k<dimNum; k++) {
  134.                 System.out.println("[" + i + "]: ");
  135.                 System.out.println("means : " + m_means[i][k]);
  136.                 System.out.println("var : " + m_vars[i][k]);
  137.                 System.out.println();
  138.             }
  139.         }
  142.         // 获取分类
  143.         for(int i=0; i<size; i++) {
  144.             System.out.println("data[" + i + "]=" + data[i] + " cindex : " + cList.get(i).cindex);
  145.         }
  147.     }
  149.     /**
  150.      * 
  151.      * @param data
  152.      */
  153.     private void initParameters(double[] data) {
  154.         // 随机方法初始化均值
  155.         int size = data.length;
  156.         for (int i = 0; i < mixNum; i++)
  157.         {
  158.             for (int d = 0; d < dimNum; d++)
  159.             {
  160.                 m_means[i][d] = data[(int)(Math.random()*size)];
  161.             }
  162.         }
  164.         // 根据均值获取分类
  165.         int[] types = new int[size];
  166.         for (int k = 0; k < size; k++)
  167.         {
  168.             double max = 0;
  169.             for (int i = 0; i < mixNum; i++)
  170.             {
  171.                 double v = 0;
  172.                 for(int j=0;j<dimNum;j++) {
  173.                     v += Math.abs(data[k*dimNum+j] - m_means[i][j]);
  174.                 }
  175.                 if(v > max) {
  176.                     max = v;
  177.                     types[k] = i;
  178.                 }
  179.             }
  180.         }
  181.         double[] counts = new double[mixNum];
  182.         for(int i=0; i<types.length; i++) {
  183.             counts[types[i]]++;
  184.         }
  186.         // 计算先验概率权重
  187.         for (int i = 0; i < mixNum; i++)
  188.         {
  189.             weights[i] = counts[i] / size;
  190.         }
  192.         // 计算每个分类的方差
  193.         int label = -1;
  194.         int[] Label = new int[size];
  195.         double[] overMeans = new double[dimNum];
  196.         double[] x = new double[dimNum];
  197.         for (int i = 0; i < size; i++)
  198.         {
  199.             for(int j=0;j<dimNum;j++)
  200.                 x[j]=data[i*dimNum+j];
  201.             label=Label[i];
  203.             // Count each Gaussian
  204.             counts[label]++;
  205.             for (int d = 0; d < dimNum; d++)
  206.             {
  207.                 m_vars[label][d] += (x[d] - m_means[types[i]][d]) * (x[d] - m_means[types[i]][d]);
  208.             }
  210.             // Count the overall mean and variance.
  211.             for (int d = 0; d < dimNum; d++)
  212.             {
  213.                 overMeans[d] += x[d];
  214.                 m_minVars[d] += x[d] * x[d];
  215.             }
  216.         }
  218.         // Compute the overall variance (* 0.01) as the minimum variance.
  219.         for (int d = 0; d < dimNum; d++)
  220.         {
  221.             overMeans[d] /= size;
  222.             m_minVars[d] = Math.max(MIN_VAR, 0.01 * (m_minVars[d] / size - overMeans[d] * overMeans[d]));
  223.         }
  225.         // Initialize each Gaussian.
  226.         for (int i = 0; i < mixNum; i++)
  227.         {
  229.             if (weights[i] > 0)
  230.             {
  231.                 for (int d = 0; d < dimNum; d++)
  232.                 {
  233.                     m_vars[i][d] = m_vars[i][d] / counts[i];
  235.                     // A minimum variance for each dimension is required.
  236.                     if (m_vars[i][d] < m_minVars[d])
  237.                     {
  238.                         m_vars[i][d] = m_minVars[d];
  239.                     }
  240.                 }
  241.             }
  242.         }
  244.         System.out.println("=================初始化=================");
  245.         for(int i=0; i<mixNum; i++) {
  246.             for(int k=0; k<dimNum; k++) {
  247.                 System.out.println("[" + i + "]: ");
  248.                 System.out.println("means : " + m_means[i][k]);
  249.                 System.out.println("var : " + m_vars[i][k]);
  250.                 System.out.println();
  251.             }
  252.         }
  254.     }
  256.     /***
  257.      * 
  258.      * @param sample - 采样数据点
  259.      * @return 该点总概率密度分布可能性
  260.      */
  261.     public double getProbability(double[] sample)
  262.     {
  263.         double p = 0;
  264.         for (int i = 0; i < mixNum; i++)
  265.         {
  266.             p += weights[i] * getProbability(sample, i);
  267.         }
  268.         return p;
  269.     }
  271.     /**
  272.      * Gaussian Model -> PDF
  273.      * @param x - 表示采样数据点向量
  274.      * @param j - 表示对对应的第J个分类的概率密度分布
  275.      * @return - 返回概率密度分布可能性值
  276.      */
  277.     public double getProbability(double[] x, int j)
  278.     {
  279.         double p = 1;
  280.         for (int d = 0; d < dimNum; d++)
  281.         {
  282.             p *= 1 / Math.sqrt(2 * 3.14159 * m_vars[j][d]);
  283.             p *= Math.exp(-0.5 * (x[d] - m_means[j][d]) * (x[d] - m_means[j][d]) / m_vars[j][d]);
  284.         }
  285.         return p;
  286.     }
  288.     public static void main(String[] args) {
  289.         GMMProcessor filter = new GMMProcessor(1, 2);
  290.         filter.process(samples);
  292.     }
  293. }

结构类DataNode

  1. package com.gloomyfish.image.gmm;
  3. public class DataNode {
  4.     public int cindex; // cluster
  5.     public int index;
  6.     public double[] value;
  8.     public DataNode(double[] v) {
  9.         this.value = v;
  10.         cindex = -1;
  11.         index = -1;
  12.     }
  13. }

五：结果

SouthEast

这里初始中心均值的方法我是通过随机数来实现，GMM算法运行结果跟初始化有很大关系，常见初始化中心点的方法是通过K-Means来计算出中心点。大家可以尝试修改代码基于K-Means初始化参数，我之所以选择随机参数初始，主要是为了省事！

不炒作概念，只分享干货！

请继续关注本博客！

发表评论

表情：
评论列表 （有 0 条评论，307人围观）

还没有评论，来说两句吧...

相关阅读

    相关 图像处理之高斯混合模型

    一、高斯混合模型 现有的图像中目标的分类常用深度学习模型处理，但是深度学习需要大量模型处理。对于明显提取的目标，常常有几个明显特征，利用这几个明显特征使用少量图片便可以完

    蔚落蔚落/ 0 赞/ 129 阅读

    相关 高斯混合模型（GMM）

    1. 前言 高斯混合模型是使用高斯分布对原始数据进行估计，其中高斯函数的均值 μ \\mu μ和方差 σ \\sigma σ以及各个高斯函数分量占的比例 α \\alph

    蔚落蔚落/ 0 赞/ 313 阅读