LDA程式碼：

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)
		self.nw = np.zeros((self.dpre.words_count, self.K), dtype="int")
		self.nwsum = np.zeros(self.K, dtype="int")
		self.nd = np.zeros((self.dpre.docs_count, self.K), dtype="int")
		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]
		word = self.dpre.docs[i].words[j]
		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

		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 f_perplexity(word_frequency,word_count):             #計算困惑度
    
    duishu=-math.log(word_frequency)
    kuohaoli=duishu/word_count
    perplexity=math.exp(kuohaoli)
    return perplexity