论文阅读-BoVW-pLSA

• 论文链接：Medical Image BoVW-pLSA
• 文章大意：其实和BoVW-MI差不多，也都是在原来的词库上选择一些更具代表性的词汇。只不过将原来mutual information更换成了这里的PLSA方法，PLSA详细介绍请看下文。

• PLSA（probabilistic Latent Semantic Analysis）

  • 首先我们先明白一下单词的意思：
    
    • word：视觉单词，代表的是通过BoVW方法得到的视觉单词
    • document：文档，在这里代表的就是一个样本sample
    • concept：主题，比如说我们的我们的单词包括{内存、CPU、历史、悬疑}等词汇的时候，我们的主题可能就包括{计算机、小说}等。注意，在这里主题的个数是由我们指定得到的。
  • 明白了上述的概念后，我们怎么来挑选我们想要的单词呢？我们可以计算每个主题和每个单词，每个主题和每个文档的紧密程度，知道了这些我们就按照一定的比例挑选出来我们想要的单词了吧。但是怎么计算这个紧密程度呢？pLSA给出了如下的算法：
    
    
    
    
    • 其中wj代表的是第j个单词，zk代表的是第k个主题、di代表的是第i个文档.
    • n(di, wj)代表的是第i个文档中，单词j的个数
    • n(di)代表的是第i文档中所有单词的个数
    • 所以我们就可以得到单词和主题的紧密程度矩阵P(w|z)
  • 知道了上诉算法，那我们怎么计算呢？
    
    • 首先我们先给P(w|z) 和 P(z|d) 初始化为随机数
    • 然后先后更新P(z|d,w) P(w|z) P(z|d)
    • 一直迭代直到P(z|d,w)的新旧之差小于一个阈值，也就是所谓的收敛。
  • 计算矩阵的代码如下所示：
    

    def calu_two_matrix(image_hist, k=100):
    shape = list(np.shape(image_hist))
    p_w_z = np.zeros(
        [shape[1], k],
        dtype=np.float32
    )
    p_z_d = np.zeros(
        [k, shape[0]],
        dtype=np.float32
    )
    p_z_d_w = np.zeros(
        [k, shape[0], shape[1]],
        dtype=np.float32
    )
    p_z_d = np.random.random([k, shape[0]])
    for zi in range(k):
        normalize(p_z_d[zi])
    p_w_z = np.random.random([shape[1], k])
    for wi in range(shape[1]):
        normalize(p_w_z[wi])
    while True:
        # update p(z|d,w)
        p_z_d_w_new = np.zeros(
            [k, shape[0], shape[1]],
            dtype=np.float32
        )
        for zi in range(k):
            for di in range(shape[0]):
                for wi in range(shape[1]):
                    sum = 0.0
                    for zii in range(k):
                        sum += (p_w_z[wi, zii] + p_z_d[zii, di])
                    temp = p_w_z[wi, zi] * p_z_d[zi, di] * 1.0
                    temp /= (sum * 1.0)
                    p_z_d_w_new[zi, di, wi] = temp
        p_w_z_new = np.zeros(
            [shape[1], k],
            dtype=np.float32
        )
        p_z_d_new = np.zeros(
            [k, shape[0]],
            dtype=np.float32
        )
        # update p(w|z)
        sum_p_w_z_byk = {}
        for zi in range(k):
            sum_p_w_z = 0.0
            for wii in range(shape[1]):
                for dii in range(shape[0]):
                    sum_p_w_z += (image_hist[dii, wii] * p_z_d_w_new[zi, dii, wii])
            sum_p_w_z_byk[zi] = sum_p_w_z
        for wi in range(shape[1]):
            for zi in range(k):
                sum_up = 0.0
                for dii in range(shape[0]):
                    sum_up += (image_hist[dii, wi] * p_z_d_w_new[zi, dii, wi])
                sum_down = sum_p_w_z_byk[zi]
                temp = (sum_up * 1.0) / (sum_down * 1.0)
                p_w_z_new[wi, zi] = temp
    
        # update p(z,d)
        nd = []
        for dii in range(shape[0]):
            temp = 0.0
            for wii in range(shape[1]):
                temp += image_hist[dii, wii]
            nd.append(temp)
        for zi in range(k):
            for di in range(shape[0]):
                sum_up = 0.0
                for wii in range(shape[1]):
                    sum_up += (image_hist[di, wii] * p_z_d_w_new[zi, di, wii])
                temp = (sum_up * 1.0) / (nd[di])
                p_z_d_new[zi, di] = temp
        diff = math.fabs(
            np.sum(p_z_d_w_new - p_z_d_w)
        )
        p_z_d_w = p_z_d_w_new
        p_w_z = p_w_z_new
        p_z_d = p_z_d_new
        print 'diff is %g' % diff

• 此外，再给一个完整的项目代码为例，代码地址：GitHub BoVW-pLSA

• 详情阅读README文档