2. 程式人生 > >LDA主題模型原理解析與python實現

LDA主題模型原理解析與python實現

阿新 • • 發佈：2019-01-27

LDA(Latent dirichlet allocation)[1]是有Blei於2003年提出的三層貝葉斯主題模型，通過無監督的學習方法發現文字中隱含的主題資訊，目的是要以無指導學習的方法從文字中發現隱含的語義維度-即“Topic”或者“Concept”。隱性語義分析的實質是要利用文字中詞項(term)的共現特徵來發現文字的Topic結構，這種方法不需要任何關於文字的背景知識。文字的隱性語義表示可以對“一詞多義”和“一義多詞”的語言現象進行建模，這使得搜尋引擎系統得到的搜尋結果與使用者的query在語義層次上match，而不是僅僅只是在詞彙層次上出現交集。文件、主題以及詞可以表示為下圖：


LDA引數：

K為主題個數，M為文件總數，是第m個文件的單詞總數。 是每個Topic下詞的多項分佈的Dirichlet先驗引數，   是每個文件下Topic的多項分佈的Dirichlet先驗引數。是第m個文件中第n個詞的主題，是m個文件中的第n個詞。剩下來的兩個隱含變數和分別表示第m個文件下的Topic分佈和第k個Topic下詞的分佈，前者是k維(k為Topic總數)向量，後者是v維向量（v為詞典中term總數）。

LDA生成過程：

所謂生成模型，就是說，我們認為一篇文章的每個詞都是通過“以一定概率選擇了某個主題，並從這個主題中以一定概率選擇某個詞語”這樣一個過程得到。文件到主題服從多項式分佈，主題到詞服從多項式分佈。每一篇文件代表了一些主題所構成的一個概率分佈，而每一個主題又代表了很多單詞所構成的一個概率分佈。



Gibbs Sampling學習LDA：

Gibbs Sampling 是Markov-Chain Monte Carlo演算法的一個特例。這個演算法的執行方式是每次選取概率向量的一個維度，給定其他維度的變數值Sample當前維度的值。不斷迭代，直到收斂輸出待估計的引數。初始時隨機給文字中的每個單詞分配主題,然後統計每個主題z下出現term t的數量以及每個文件m下出現主題z中的詞的數量，每一輪計算，即排除當前詞的主題分配，根據其他所有詞的主題分配估計當前詞分配各個主題的概率。當得到當前詞屬於所有主題z的概率分佈後，根據這個概率分佈為該詞sample一個新的主題。然後用同樣的方法不斷更新下一個詞的主題，直到發現每個文件下Topic分佈

和每個Topic下詞的分佈收斂，演算法停止，輸出待估計的引數和，最終每個單詞的主題也同時得出。實際應用中會設定最大迭代次數。每一次計算的公式稱為Gibbs updating rule.下面我們來推導LDA的聯合分佈和Gibbs updating rule。

用Gibbs Sampling 學習LDA引數的演算法虛擬碼如下：


python實現：

#-*- coding:utf-8 -*-
import logging
import logging.config
import ConfigParser
import numpy as np
import random
import codecs
import os

from collections import OrderedDict
#獲取當前路徑
path = os.getcwd()
#匯入日誌配置檔案
logging.config.fileConfig("logging.conf")
#建立日誌物件
logger = logging.getLogger()
# loggerInfo = logging.getLogger("TimeInfoLogger")
# Consolelogger = logging.getLogger("ConsoleLogger")

#匯入配置檔案
conf = ConfigParser.ConfigParser()
conf.read("setting.conf") 
#檔案路徑
trainfile = os.path.join(path,os.path.normpath(conf.get("filepath", "trainfile")))
wordidmapfile = os.path.join(path,os.path.normpath(conf.get("filepath","wordidmapfile")))
thetafile = os.path.join(path,os.path.normpath(conf.get("filepath","thetafile")))
phifile = os.path.join(path,os.path.normpath(conf.get("filepath","phifile")))
paramfile = os.path.join(path,os.path.normpath(conf.get("filepath","paramfile")))
topNfile = os.path.join(path,os.path.normpath(conf.get("filepath","topNfile")))
tassginfile = os.path.join(path,os.path.normpath(conf.get("filepath","tassginfile")))
#模型初始引數
K = int(conf.get("model_args","K"))
alpha = float(conf.get("model_args","alpha"))
beta = float(conf.get("model_args","beta"))
iter_times = int(conf.get("model_args","iter_times"))
top_words_num = int(conf.get("model_args","top_words_num"))
class Document(object):
    def __init__(self):
        self.words = []
        self.length = 0
#把整個文件及真的單詞構成vocabulary（不允許重複）
class DataPreProcessing(object):
    def __init__(self):
        self.docs_count = 0
        self.words_count = 0
        #儲存每個文件d的資訊(單詞序列，以及length)
        self.docs = []
        #建立vocabulary表，照片文件的單詞
        self.word2id = OrderedDict()
    def cachewordidmap(self):
        with codecs.open(wordidmapfile, 'w','utf-8') as f:
            for word,id in self.word2id.items():
                f.write(word +"\t"+str(id)+"\n")
class LDAModel(object):
    def __init__(self,dpre):
        self.dpre = dpre #獲取預處理引數
        #
        #模型引數
        #聚類個數K，迭代次數iter_times,每個類特徵詞個數top_words_num,超引數α（alpha） β(beta)
        #
        self.K = K
        self.beta = beta
        self.alpha = alpha
        self.iter_times = iter_times
        self.top_words_num = top_words_num 
        #
        #檔案變數
        #分好詞的檔案trainfile
        #詞對應id檔案wordidmapfile
        #文章-主題分佈檔案thetafile
        #詞-主題分佈檔案phifile
        #每個主題topN詞檔案topNfile
        #最後分派結果檔案tassginfile
        #模型訓練選擇的引數檔案paramfile
        #
        self.wordidmapfile = wordidmapfile
        self.trainfile = trainfile
        self.thetafile = thetafile
        self.phifile = phifile
        self.topNfile = topNfile
        self.tassginfile = tassginfile
        self.paramfile = paramfile
        # p,概率向量 double型別，儲存取樣的臨時變數
        # nw,詞word在主題topic上的分佈
        # nwsum,每各topic的詞的總數
        # nd,每個doc中各個topic的詞的總數
        # ndsum,每各doc中詞的總數
        self.p = np.zeros(self.K)
        # nw,詞word在主題topic上的分佈
        self.nw = np.zeros((self.dpre.words_count,self.K),dtype="int")
        # nwsum,每各topic的詞的總數
        self.nwsum = np.zeros(self.K,dtype="int")
        # nd,每個doc中各個topic的詞的總數
        self.nd = np.zeros((self.dpre.docs_count,self.K),dtype="int")
        # ndsum,每各doc中詞的總數
        self.ndsum = np.zeros(dpre.docs_count,dtype="int")
        self.Z = np.array([ [0 for y in xrange(dpre.docs[x].length)] for x in xrange(dpre.docs_count)])        # M*doc.size()，文件中詞的主題分佈

        #隨機先分配型別，為每個文件中的各個單詞分配主題
        for x in xrange(len(self.Z)):
            self.ndsum[x] = self.dpre.docs[x].length
            for y in xrange(self.dpre.docs[x].length):
                topic = random.randint(0,self.K-1)#隨機取一個主題
                self.Z[x][y] = topic#文件中詞的主題分佈
                self.nw[self.dpre.docs[x].words[y]][topic] += 1
                self.nd[x][topic] += 1
                self.nwsum[topic] += 1

        self.theta = np.array([ [0.0 for y in xrange(self.K)] for x in xrange(self.dpre.docs_count) ])
        self.phi = np.array([ [ 0.0 for y in xrange(self.dpre.words_count) ] for x in xrange(self.K)]) 
    def sampling(self,i,j):
        #換主題
        topic = self.Z[i][j]
        #只是單詞的編號，都是從0開始word就是等於j
        word = self.dpre.docs[i].words[j]
        #if word==j:
        #    print 'true'
        self.nw[word][topic] -= 1
        self.nd[i][topic] -= 1
        self.nwsum[topic] -= 1
        self.ndsum[i] -= 1

        Vbeta = self.dpre.words_count * self.beta
        Kalpha = self.K * self.alpha
        self.p = (self.nw[word] + self.beta)/(self.nwsum + Vbeta) * \
                 (self.nd[i] + self.alpha) / (self.ndsum[i] + Kalpha)

        #隨機更新主題的嗎
        # for k in xrange(1,self.K):
        #     self.p[k] += self.p[k-1]
        # u = random.uniform(0,self.p[self.K-1])
        # for topic in xrange(self.K):
        #     if self.p[topic]>u:
        #         break

        #按這個更新主題更好理解，這個效果還不錯
        p = np.squeeze(np.asarray(self.p/np.sum(self.p)))
        topic = np.argmax(np.random.multinomial(1, p))

        self.nw[word][topic] +=1
        self.nwsum[topic] +=1
        self.nd[i][topic] +=1
        self.ndsum[i] +=1
        return topic
    def est(self):
        # Consolelogger.info(u"迭代次數為%s 次" % self.iter_times)
        for x in xrange(self.iter_times):
            for i in xrange(self.dpre.docs_count):
                for j in xrange(self.dpre.docs[i].length):
                    topic = self.sampling(i,j)
                    self.Z[i][j] = topic
        logger.info(u"迭代完成。")
        logger.debug(u"計算文章-主題分佈")
        self._theta()
        logger.debug(u"計算詞-主題分佈")
        self._phi()
        logger.debug(u"儲存模型")
        self.save()
    def _theta(self):
        for i in xrange(self.dpre.docs_count):#遍歷文件的個數詞
            self.theta[i] = (self.nd[i]+self.alpha)/(self.ndsum[i]+self.K * self.alpha)
    def _phi(self):
        for i in xrange(self.K):
            self.phi[i] = (self.nw.T[i] + self.beta)/(self.nwsum[i]+self.dpre.words_count * self.beta)
    def save(self):
        # 儲存theta文章-主題分佈
        logger.info(u"文章-主題分佈已儲存到%s" % self.thetafile)
        with codecs.open(self.thetafile,'w') as f:
            for x in xrange(self.dpre.docs_count):
                for y in xrange(self.K):
                    f.write(str(self.theta[x][y]) + '\t')
                f.write('\n')
        # 儲存phi詞-主題分佈
        logger.info(u"詞-主題分佈已儲存到%s" % self.phifile)
        with codecs.open(self.phifile,'w') as f:
            for x in xrange(self.K):
                for y in xrange(self.dpre.words_count):
                    f.write(str(self.phi[x][y]) + '\t')
                f.write('\n')
        # 儲存引數設定
        logger.info(u"引數設定已儲存到%s" % self.paramfile)
        with codecs.open(self.paramfile,'w','utf-8') as f:
            f.write('K=' + str(self.K) + '\n')
            f.write('alpha=' + str(self.alpha) + '\n')
            f.write('beta=' + str(self.beta) + '\n')
            f.write(u'迭代次數  iter_times=' + str(self.iter_times) + '\n')
            f.write(u'每個類的高頻詞顯示個數  top_words_num=' + str(self.top_words_num) + '\n')
        # 儲存每個主題topic的詞
        logger.info(u"主題topN詞已儲存到%s" % self.topNfile)

        with codecs.open(self.topNfile,'w','utf-8') as f:
            self.top_words_num = min(self.top_words_num,self.dpre.words_count)
            for x in xrange(self.K):
                f.write(u'第' + str(x) + u'類：' + '\n')
                twords = []
                twords = [(n,self.phi[x][n]) for n in xrange(self.dpre.words_count)]
                twords.sort(key = lambda i:i[1], reverse= True)
                for y in xrange(self.top_words_num):
                    word = OrderedDict({value:key for key, value in self.dpre.word2id.items()})[twords[y][0]]
                    f.write('\t'*2+ word +'\t' + str(twords[y][1])+ '\n')
        # 儲存最後退出時，文章的詞分派的主題的結果
        logger.info(u"文章-詞-主題分派結果已儲存到%s" % self.tassginfile)
        with codecs.open(self.tassginfile,'w') as f:
            for x in xrange(self.dpre.docs_count):
                for y in xrange(self.dpre.docs[x].length):
                    f.write(str(self.dpre.docs[x].words[y])+':'+str(self.Z[x][y])+ '\t')
                f.write('\n')
        logger.info(u"模型訓練完成。")
# 資料預處理，即：生成d（）單詞序列，以及詞彙表
def preprocessing():
    logger.info(u'載入資料......')
    with codecs.open(trainfile, 'r','utf-8') as f:
        docs = f.readlines()
    logger.debug(u"載入完成,準備生成字典物件和統計文字資料...")
    # 大的文件集
    dpre = DataPreProcessing()
    items_idx = 0
    for line in docs:
        if line != "":
            tmp = line.strip().split()
            # 生成一個文件物件：包含單詞序列（w1,w2,w3,,,,,wn）可以重複的
            doc = Document()
            for item in tmp:
                if dpre.word2id.has_key(item):# 已有的話，只是當前文件追加
                    doc.words.append(dpre.word2id[item])
                else:  # 沒有的話，要更新vocabulary中的單詞詞典及wordidmap
                    dpre.word2id[item] = items_idx
                    doc.words.append(items_idx)
                    items_idx += 1
            doc.length = len(tmp)
            dpre.docs.append(doc)
        else:
            pass
    dpre.docs_count = len(dpre.docs) # 文件數
    dpre.words_count = len(dpre.word2id) # 詞彙數
    logger.info(u"共有%s個文件" % dpre.docs_count)
    dpre.cachewordidmap()
    logger.info(u"詞與序號對應關係已儲存到%s" % wordidmapfile)
    return dpre
def run():
    # 處理文件集，及計算文件數，以及vocabulary詞的總個數，以及每個文件的單詞序列
    dpre = preprocessing()
    lda = LDAModel(dpre)
    lda.est()
if __name__ == '__main__':
    run()


參考資料：

lda八卦

相關推薦

LDA主題模型原理解析與python實現

LDA(Latent dirichlet allocation)[1]是有Blei於2003年提出的三層貝葉斯主題模型，通過無監督的學習方法發現文字中隱含的主題資訊，目的是要以無指導學習的方法從文字中發現隱含的語義維度-即“Topic”或者“Concept”。隱性語義分析的

K近鄰演算法(KNN)原理解析及python實現程式碼

KNN演算法是一個有監督的演算法，也就是樣本是有標籤的。KNN可以用於分類，也可以用於迴歸。這裡主要講knn在分類上的原理。KNN的原理很簡單：            放入一個待分類的樣本，使用者指定k的大小，然後計算所有訓練樣本與該樣

名人問題 演算法解析與Python 實現 O(n) 複雜度 （以Leetcode 277. Find the Celebrity為例）

1. 題目描述 Problem Description Leetcode 277. Find the Celebrity Suppose you are at a party with n people (labeled from 0 to n -

Android 圖片三級快取載入框架原理解析與程式碼實現

本文主要介紹三級快取的原理解析與實現方式。以前一直覺得三級快取圖片載入是一個很難理解的東西，但是自己看了一下午再試著寫了一遍之後感覺還是隻要沉下心思考還時很容易熟悉掌握的。 所謂三級快取：首先是記憶體-檔案(外存)-網路三級快取機制。 首先： 框架需要一個接入方法NGIm

【大創_社區劃分】——PageRank演算法的解析與Python實現

一、什麼是pagerank PageRank的Page可是認為是網頁，表示網頁排名，也可以認為是Larry Page(google 產品經理)，因為他是這個演算法的發明者之一，還是google CEO

lda主題模型python實現篇

個人部落格地址：http://xurui.club/2018/06/01/lda/ 最近在做一個動因分析的專案，自然想到了主題模型LDA。這次先把模型流程說下，原理後面再講。 lda實現有很多開源庫，這裡用的是gensim. 1 文字預處理 大概說下文字

LDA主題模型及python實現

LDA(Latent Dirichlet Allocation)中文翻譯為：潛在狄利克雷分佈。LDA主題模型是一種文件生成模型，是一種非監督機器學習技術。它認為一篇文件是有多個主題的，而每個主題又對應著不同的詞。一篇文件的構造過程，首先是以一定的概率選擇某個主題，然後再在這個主題下以一定

GAN原理解析，公式推導與python實現

1-生成模型 1-1 生成模型與判別模型 生成式對抗網路，顧名思義就是生成模型嘛！那什麼是生成模型呢？與判別模型有什麼區別呢？ 先來理解一下判別模型。 學過機器學習的人都知道，入門級的演算法邏輯迴歸，最後的預測，是通過sigmoid函式：

vue.js響應式原理解析與實現

github 遞歸 val 實現 mode 最新 中比 ava 新頁面 從很久之前就已經接觸過了angularjs了，當時就已經了解到，angularjs是通過臟檢查來實現數據監測以及頁面更新渲染。之後，再接觸了vue.js，當時也一度很好奇vue.js是如何監測數據更新並

灰度圖的直方圖均衡化(Histogram Equalization)原理與 Python 實現

p { margin-bottom: 0.1in; direction: ltr; line-height: 120%; text-align: justify; orphans: 0; widows: 0 } 原理 　　直方圖均衡化是一種通過使用影象直方圖，調整對比度的影象處理方法；通過對影象的強度（i

vue.js響應式原理解析與實現—實現v-model與{{}}指令

只需要 spl foreach 形式 pen for 元素節點 目標 @param 離線瀏覽器軟件 服務器遠程連接 1、可多站同時下載、多站同時扒 2、可單頁扒 3、可自定義， 重寫JS\圖片\CSS路徑 4、執行全站下載後，會下載到本程序根目錄下的html文件夾下。

【機器學習】Weighted LSSVM原理與Python實現：LSSVM的稀疏化改進

【機器學習】Weighted LSSVM原理與Python實現：LSSVM的稀疏化改進 一、LSSVM 1、LSSVM用於迴歸 2、LSSVM模型的缺點 二、WLSSVM的數學原理 三、WLSSVM的python實現 參

【機器學習】最小二乘法支援向量機LSSVM的數學原理與Python實現

【機器學習】最小二乘法支援向量機LSSVM的數學原理與Python實現 一、LSSVM數學原理 1. 感知機 2. SVM 3. LSSVM 4. LSSVM與SVM的區別 二、LSSVM的py

主題模型TopicModel：通過gensim實現LDA

使用python gensim輕鬆實現lda模型。gensim簡介gemsim是一個免費python庫，能夠從文件中有效地自動抽取語義主題。gensim中的演算法包括：LSA(Latent Semantic Analysis), LDA(Latent Dirichlet Al

R語言實現LDA主題模型分析知乎話題

 這是一篇關於文字主題分析的應用實踐，主要嘗試聚焦幾個問題，什麼是LDA主題模型？如何使用LDA主題模型進行文字？我們將知乎上面的轉基因話題精華帖下面的提問分成六大主題進行實踐。 轉基因“風雲再起” 2017年5月18日璞谷塘悄然開張，這是小崔線上販賣非轉基因食品的網

LDA主題模型程式碼實現流程

本文主要是通過閱讀別人實現的LAD主題模型程式碼,總結的一個實現流程,供別人想實現LAD時可作參考,如若有何錯誤,麻煩請指出: LDA程式碼流程: (1) 先對文件切詞,然後對每個詞語賦ID編號0~(n-1),計算共有n個詞,m個文件 (2) 引數,變數設定: K 主題

決策樹演算法原理 與 Python實現

轉自： https://blog.csdn.net/huahuazhu/article/details/73167610?locationNum=2&fps=1    ###########################################

資料探勘十大演算法（五）：EM(Expectation Maximum)演算法原理與Python實現

參考： 一、一個簡單的概率問題 實驗：現在有A和B兩個硬幣，我們從這兩個硬幣中，隨機選取5次，做5組實驗，每組實驗內容是：丟擲所選的硬幣，記錄正反面。 實驗資料如下： 目標：根據所得到的實驗資料，分別求出硬幣A和B丟擲後正面向上的概率。 根據古典概率的原

資料探勘十大演算法（九）：樸素貝葉斯原理、例項與Python實現

一、條件概率的定義與貝葉斯公式 二、樸素貝葉斯分類演算法 樸素貝葉斯是一種有監督的分類演算法，可以進行二分類，或者多分類。一個數據集例項如下圖所示： 現在有一個新的樣本， X = (年齡：<=30, 收入：中， 是否學生：是， 信譽：中)，目標是利用樸素貝

蒙特.卡羅方法求解圓周率近似值原理與Python實現

對於某些不能精確求解的問題，蒙特.卡羅方法是一種非常巧妙的尋找近似解的方法。 以求解圓周率的問題為例，假設有一個單位圓及其外切正方形，我們往正方形內扔飛鏢，當扔的次數足夠多以後，“落在圓內的次數/落在正方形內的次數”這個比值會無限接近“圓的面積/正方形的面積”這個比值，也就是圓周率的四分之一。模擬扔飛鏢的次