贝叶斯学习

贝叶斯公式

贝叶斯学习器其实是从经典的贝叶斯概率公式的来的，对于经典的贝叶斯公式：

$$P(A|B)={P(B|A)P(A)\over{P(B)}}$$
式中P(A)表示A的先验概率（即A发生的概率与B无关），P(A|B)表示A的后验概率（即在已知B发生的情况下，A发生的概率）

朴素贝叶斯分类

我们都知道贝叶斯是一个经典的求取概率的公式，那么贝叶斯又是怎么和分类相联系起来的呢？

实际上，在分类的过程中，我们要判断某样本x是否属于某类别A时，可以将这件事看成是个概率问题，即判断x属于A的可能性有多大。假设类别有n种，则只需求取x分别属于每个样本的概率有多大，概率值最大的，即可认为是x的所属类别。

朴素贝叶斯分类的正式定义如下：
1. 设$x=\{a_1,a_2,...,a_m \}$为一个带分类项，其中每个$a$的为x的一个特征属性.
2. 有类别集合

$$$C=\{y_1,y_2,...y_n\}$$ $。

1. 计算$P(y_1|x)$，$P(y_2|x)$，…，$P(y_n|x)$。

2. 如果$P(y_k|x)=max\{(y_1|x),P(y_2|x),...,P(y_n|x)\}$
   则$x\in y_k$

现在从定义可以看出每步并不难理解。关键时第三步中的每个概率值怎么求取。对于单个变量，求取其概率值比较好求，可是这里的x时一个含有m个属性的变量，这种情况下，该怎么求取其属于某类别$y_n$的概率是多少呢？

下面给出求解推导：
已知我们要求取$P(y_i|x)$的概率值，根据贝叶斯公式可以将其转换为如下形式：

$$P(y_i|x)={P(x|y_i)P(y_i)\over{P(x)}}$$
所以求取$P(y_i|x)$就变成了求${P(x|y_i)P(y_i)\over{P(x)}}$。
对于$P(x|y_i)$，因为x含有m个属性变量，因此可以将其写成$P(\{a_1,a_2,...,a_m\}|y_i)$。对于大多数情况，x的各个属性之间都是相互独立，所以有：
$$P(x|y_i)P(y_i)=P(a_1|y_i)P(a_2|y_i)...P(a_m|y_i)P(y_i)=P(y_i){\prod_{j=1}^{m}}P(a_j|y_i)$$
因此：
$$P(y_i|x)={P(y_i){\prod_{j=1}^{m}}P(a_j|y_i)\over P(x)}$$
至此，便得到了$P(y_i|x)$的概率值求解表达式，不过这里的P(X)的值不知道为多少。但是，根据贝叶斯分类的思想，我们只要找到概率最大的一项即即可，对于不同的类别$y_i$，$P(y_i|x)$最终的求解表达式中都含有P(X)，因此只要求解，使$P(y_i){\prod_{j=1}^{m}}P(a_j|y_i)$最大即可。

朴素贝叶斯分类应用实例（目标跟踪）

对于目标跟踪，目前用的比较多的方法都是在待跟踪目标区域周围获取候选窗口，然后判断这些候选窗口是否是目标。在判断的过程中，往往采都是计算候选窗口属于时目标的概率值，值越大，则其时目标的可能性就越大。这种思想和朴素贝叶斯分类的思想非常相似。

下面以压缩感知跟踪为例。
在感知压缩跟踪，作者将贝叶斯当成了一个在线学习的分类器，此分类器在分为分类和更新参数两个部分。

在分类阶段（第t帧）

首先在目标框（t-1帧确定的位置）周围一定范围内选取m个候选框。对候选框提取特征，得到特征向量$\vec{v}=(v_1,v_2,...,v_n)$每个向量都含有n个属性值，现要求$\vec{v}$是后选框的概率值，根据朴素贝叶斯可知：

$$P(y=1|\vec{v})={P(y=1){\prod_{i=1}^{n}}P(v_j|y=1)\over P(\vec v)}$$
但是要是单纯的求取这个式子并不好求，因为我们并不知道式子中$P(\vec v)$的概率值。
不过，注意到既然不能求解$P(\vec v)$，那是否可以将这一项消去？

因此将求取$P(y=1|\vec{v})$转化为求取$P(y=1|\vec{v})\over P(y=0|\vec{v})$。

$${P(y=1|\vec{v})\over P(y=0|\vec{v})}={P(y=1){\prod_{i=1}^{n}}P(v_j|y=1)\over P(y=0){\prod_{i=1}^{n}}P(v_j|y=0)}=\sum_{i=1}^n{log({{\prod_{i=1}^{n}}P(v_j|y=1)\over {\prod_{i=1}^{n}}P(v_j|y=0)} )}$$
这里假定先验概率$P(y=1)=P(y=0)$,y代表样本标签。
其中：
$$P(v_i|y=1)\sim N(\mu_i^1,\sigma_i^1)$$
$$P(v_i|y=0)\sim N(\mu_i^0,\sigma_i^0)$$

在参数更新阶段（第t帧）

在分类阶段时，已经确定了第t帧中目标所在的位置，接下来来便更新学习机的参数。，会在目标框周围一定范围$\alpha$内获取m个候选框（$\alpha$代表到目标框中心位置的距离），将其定为正样本；然后在范围$(\alpha ,\beta)$内获取n个负样本框（$m\approx n$）。得到正负样本后，便开始跟新分类器的参数，更新方式如下：

$$\mu_i^1 \leftarrow \lambda \mu_i^1 +(1-\lambda)\mu^1$$
$$\sigma_i^1 \leftarrow \sqrt{\lambda(\sigma_i^1)^2+(1-\lambda)(\sigma^1)^2+\lambda(1-\lambda)(\mu_i^1-\mu^1)^2}$$
式子中的$\lambda$时学习参数。

实践代码

这是分类代码

void CompressiveTracker::radioClassifier(vector<float>& _muPos, vector<float>& _sigmaPos, vector<float>& _muNeg, vector<float>& _sigmaNeg,
                                         Mat& _sampleFeatureValue, float& _radioMax, int& _radioMaxIndex)
{
    float sumRadio;
    _radioMax = -FLT_MAX;
    _radioMaxIndex = 0;
    float pPos;
    float pNeg;
    int sampleBoxNum = _sampleFeatureValue.cols;

    for (int j=0; j<sampleBoxNum; j++)
    {
        sumRadio = 0.0f;
        for (int i=0; i<featureNum; i++)
        {
            pPos = exp( (_sampleFeatureValue.at<float>(i,j)-_muPos[i])*(_sampleFeatureValue.at<float>(i,j)-_muPos[i]) / -(2.0f*_sigmaPos[i]*_sigmaPos[i]+1e-30) ) / (_sigmaPos[i]+1e-30);
            pNeg = exp( (_sampleFeatureValue.at<float>(i,j)-_muNeg[i])*(_sampleFeatureValue.at<float>(i,j)-_muNeg[i]) / -(2.0f*_sigmaNeg[i]*_sigmaNeg[i]+1e-30) ) / (_sigmaNeg[i]+1e-30);
            sumRadio += log(pPos+1e-30) - log(pNeg+1e-30);  // equation 4
        }
        if (_radioMax < sumRadio)
        {
            _radioMax = sumRadio;
            _radioMaxIndex = j;
        }
    }
}

这是参数跟新代码

void CompressiveTracker::classifierUpdate(Mat& _sampleFeatureValue, vector<float>& _mu, vector<float>& _sigma, float _learnRate)
{
    Scalar muTemp;
    Scalar sigmaTemp;

    for (int i=0; i<featureNum; i++)
    {
        meanStdDev(_sampleFeatureValue.row(i), muTemp, sigmaTemp);

        _sigma[i] = (float)sqrt( _learnRate*_sigma[i]*_sigma[i] + (1.0f-_learnRate)*sigmaTemp.val[0]*sigmaTemp.val[0] 
        + _learnRate*(1.0f-_learnRate)*(_mu[i]-muTemp.val[0])*(_mu[i]-muTemp.val[0]));  // equation 6 in paper

        _mu[i] = _mu[i]*_learnRate + (1.0f-_learnRate)*muTemp.val[0];   // equation 6 in paper
    }
}