首先通俗的解释下Topic模型LDA：假如我们需要写一篇关于新上市汽车的文章，首先需要确定文章大概的主题，比如要写这辆汽车的动力、外观、内饰。确定完主题之后，就要下笔了，下笔的过程其实是在确定的主题中选择合适的词。
动力词：发动机、涡轮增压、功率、油耗、扭矩等；
外观词：氙气、天窗、后视镜、前脸、格栅灯等；
内饰词：仪表台、中控台、方向盘、座椅、靠背等。
最后加上合适的语法，文章就完成了。文章确定主题、主题确定词的过程，就是LDA过程。百度百科中的解释为：
LDA（Latent Dirichlet Allocation）是一种文档主题生成模型，也称为一个三层贝叶斯概率模型，包含词、主题和文档三层结构。所谓生成模型，即认为一篇文章的每个词都是通过“以一定概率选择了某个主题，并从这个主题中以一定概率选择某个词”这样一个过程得到。文档到主题服从多项式分布，主题到词服从多项式分布。
这篇文章中不会出现很复杂的数学公式，需要深入学习的建议百度搜索“LDA数学八卦”，我就不班门弄斧了。也不会出现各种专业的术语，比如Gibbs抽样、Dirichlet分布、共轭分布、马尔科夫链等，这些都在《LDA数学八卦》中有详细解释。同时建议有能力的读者，直接去阅读LDA作者主页：David M. Blei。
这篇文章也不会引用scikit-learn、gensim等机器学习包中的LDA代码，我们坚持“撸代码，学知识”，自己去实现这个模型。代码地址：python_lda。代码中除了利用Gibbs抽样方法（也可以改为EM算法解LDA，读者可以思考下两者的区别）实现LDA过程之外，同时对模型进行了改进，这里主要解释下改进思路：
LDA本身作为一种非监督的算法模型，同时也可能由于训练集本身存在有大量的噪声数据，可能导致模型在效果上并不能满足工业上的需求。比如我们经过一次LDA过程之后，得到的每个Topic的词列表（xxx.twords）中，多多少少的混杂有其他Topic的词语或噪声词语等，这就导致后边的inference的正确率不理想。
在LDA过程完成，得到xxx.twords文件之后，我们可以尝试根据“专家经验”，手动去除每个Topic中不应该属于该主题的词。处理完之后，相当于我们得到一个比较理想、比较干净的“先验知识”。
得到这样的“先验知识”之后，我们就可以将它当做变量传入下一次的LDA过程，并在模型初始化时，将“先验知识”中的词以较大概率落到相应的Topic中。同样的训练集、同样的参数再次迭代LDA过程。两三次这样的迭代之后，效果应该就有一定改进。
虽然能在一定程度上改进模型效果，但是这样做也有一定的弊端：大大增大了人工成本，同时如果Topic个数过多（几千上万个），也很难一个个去筛选“先验知识”。
以上是一个简单的改进思路，就在平时工作中的应用效果来看，能提高10%左右的正确率。具体实现见代码：
# _*_ coding: utf-8 _*_
"""
python_lda.py by xianhu
"""
importos
importnumpy
importlogging
fromcollectionsimportdefaultdict
# 全局变量
MAX_ITER_NUM =10000# 最大迭代次数
VAR_NUM =20# 自动计算迭代次数时,计算方差的区间大小
classBiDictionary(object):
"""
定义双向字典,通过key可以得到value,通过value也可以得到key
"""
def__init__(self):
"""
:key: 双向字典初始化
"""
self.dict = {}# 正向的数据字典,其key为self的key
self.dict_reversed = {}# 反向的数据字典,其key为self的value
return
def__len__(self):
"""
:key: 获取双向字典的长度
"""
returnlen(self.dict)
def__str__(self):
"""
:key: 将双向字典转化为字符串对象
"""
str_list = ["%s\t%s"% (key,self.dict[key])forkeyinself.dict]
return"\n".join(str_list)
defclear(self):
"""
:key: 清空双向字典对象
"""
self.dict.clear()
self.dict_reversed.clear()
return
defadd_key_value(self,key,value):
"""
:key: 更新双向字典,增加一项
"""
self.dict[key] = value
self.dict_reversed[value] = key
return
defremove_key_value(self,key,value):
"""
:key: 更新双向字典,删除一项
"""
ifkeyinself.dict:
delself.dict[key]
delself.dict_reversed[value]
return
defget_value(self,key,default=None):
"""
:key: 通过key获取value,不存在返回default
"""
returnself.dict.get(key,default)
defget_key(self,value,default=None):
"""
:key: 通过value获取key,不存在返回default
"""
returnself.dict_reversed.get(value,default)
defcontains_key(self,key):
"""
:key: 判断是否存在key值
"""
returnkeyinself.dict
defcontains_value(self,value):
"""
:key: 判断是否存在value值
"""
returnvalueinself.dict_reversed
defkeys(self):
"""
:key: 得到双向字典全部的keys
"""
returnself.dict.keys()
defvalues(self):
"""
:key: 得到双向字典全部的values
"""
returnself.dict_reversed.keys()
defitems(self):
"""
:key: 得到双向字典全部的items
"""
returnself.dict.items()
classCorpusSet(object):
"""
定义语料集类,作为LdaBase的基类
"""
def__init__(self):
"""
:key: 初始化函数
"""
# 定义关于word的变量
self.local_bi = BiDictionary()# id和word之间的本地双向字典,key为id,value为word
self.words_count =0# 数据集中word的数量（排重之前的）
self.V =0# 数据集中word的数量（排重之后的）
# 定义关于article的变量
self.artids_list = []# 全部article的id的列表,按照数据读取的顺序存储
self.arts_Z = []# 全部article中所有词的id信息,维数为 M * art.length()
self.M =0# 数据集中article的数量
# 定义推断中用到的变量（可能为空）
self.global_bi =None# id和word之间的全局双向字典,key为id,value为word
self.local_2_global = {}# 一个字典,local字典和global字典之间的对应关系
return
definit_corpus_with_file(self,file_name):
"""
:key: 利用数据文件初始化语料集数据。文件每一行的数据格式: id[tab]word1 word2 word3......
"""
withopen(file_name,"r",encoding="utf-8")asfile_iter:
self.init_corpus_with_articles(file_iter)
return
definit_corpus_with_articles(self,article_list):
"""
:key: 利用article的列表初始化语料集。每一篇article的格式为: id[tab]word1 word2 word3......
"""
# 清理数据--word数据
self.local_bi.clear()
self.words_count =0
self.V =0
# 清理数据--article数据
self.artids_list.clear()
self.arts_Z.clear()
self.M =0
# 清理数据--清理local到global的映射关系
self.local_2_global.clear()
# 读取article数据
forlineinarticle_list:
frags = line.strip().split()
iflen(frags) <2:
continue
# 获取article的id
art_id = frags[0].strip()
# 获取word的id
art_wordid_list = []
forwordin[w.strip()forwinfrags[1:]ifw.strip()]:
local_id =self.local_bi.get_key(word)ifself.local_bi.contains_value(word)elselen(self.local_bi)
# 这里的self.global_bi为None和为空是有区别的
ifself.global_biis None:
# 更新id信息
self.local_bi.add_key_value(local_id,word)
art_wordid_list.append(local_id)
else:
ifself.global_bi.contains_value(word):
# 更新id信息
self.local_bi.add_key_value(local_id,word)
art_wordid_list.append(local_id)
# 更新local_2_global
self.local_2_global[local_id] =self.global_bi.get_key(word)
# 更新类变量: 必须article中word的数量大于0
iflen(art_wordid_list) >0:
self.words_count +=len(art_wordid_list)
self.artids_list.append(art_id)
self.arts_Z.append(art_wordid_list)
# 做相关初始计算--word相关
self.V =len(self.local_bi)
logging.debug("words number: "+str(self.V) +", "+str(self.words_count))
# 做相关初始计算--article相关
self.M =len(self.artids_list)
logging.debug("articles number: "+str(self.M))
return
defsave_wordmap(self,file_name):
"""
:key: 保存word字典,即self.local_bi的数据
"""
withopen(file_name,"w",encoding="utf-8")asf_save:
f_save.write(str(self.local_bi))
return
defload_wordmap(self,file_name):
"""
:key: 加载word字典,即加载self.local_bi的数据
"""
self.local_bi.clear()
withopen(file_name,"r",encoding="utf-8")asf_load:
for_id,_wordin[line.strip().split()forlineinf_loadifline.strip()]:
self.local_bi.add_key_value(int(_id),_word.strip())
self.V =len(self.local_bi)
return
classLdaBase(CorpusSet):
"""
LDA模型的基类,相关说明:
》article的下标范围为[0, self.M), 下标为 m
》wordid的下标范围为[0, self.V), 下标为 w
》topic的下标范围为[0, self.K), 下标为 k 或 topic
》article中word的下标范围为[0, article.size()), 下标为 n
"""
def__init__(self):
"""
:key: 初始化函数
"""
CorpusSet.__init__(self)
# 基础变量--1
self.dir_path =""# 文件夹路径,用于存放LDA运行的数据、中间结果等
self.model_name =""# LDA训练或推断的模型名称,也用于读取训练的结果
self.current_iter =0# LDA训练或推断的模型已经迭代的次数,用于继续模型训练过程
self.iters_num =0# LDA训练或推断过程中Gibbs抽样迭代的总次数,整数值或者"auto"
self.topics_num =0# LDA训练或推断过程中的topic的数量,即self.K值
self.K =0# LDA训练或推断过程中的topic的数量,即self.topics_num值
self.twords_num =0# LDA训练或推断结束后输出与每个topic相关的word的个数
# 基础变量--2
self.alpha = numpy.zeros(self.K)# 超参数alpha,K维的float值,默认为50/K
self.beta = numpy.zeros(self.V)# 超参数beta,V维的float值,默认为0.01
# 基础变量--3
self.Z = []# 所有word的topic信息,即Z(m, n),维数为 M * article.size()
# 统计计数(可由self.Z计算得到)
self.nd = numpy.zeros((self.M,self.K))# nd[m, k]用于保存第m篇article中第k个topic产生的词的个数,其维数为 M * K
self.ndsum = numpy.zeros((self.M,1))# ndsum[m, 0]用于保存第m篇article的总词数,维数为 M * 1
self.nw = numpy.zeros((self.K,self.V))# nw[k, w]用于保存第k个topic产生的词中第w个词的数量,其维数为 K * V
self.nwsum = numpy.zeros((self.K,1))# nwsum[k, 0]用于保存第k个topic产生的词的总数,维数为 K * 1
# 多项式分布参数变量
self.theta = numpy.zeros((self.M,self.K))# Doc-Topic多项式分布的参数,维数为 M * K,由alpha值影响
self.phi = numpy.zeros((self.K,self.V))# Topic-Word多项式分布的参数,维数为 K * V,由beta值影响
# 辅助变量,目的是提高算法执行效率
self.sum_alpha =0.0# 超参数alpha的和
self.sum_beta =0.0# 超参数beta的和
# 先验知识,格式为{word_id: [k1, k2, ...], ...}
self.prior_word = defaultdict(list)
# 推断时需要的训练模型
self.train_model =None
return
# --------------------------------------------------辅助函数---------------------------------------------------------
definit_statistics_document(self):
"""
:key: 初始化关于article的统计计数。先决条件: self.M, self.K, self.Z
"""
assertself.M >0andself.K >0andself.Z
# 统计计数初始化
self.nd = numpy.zeros((self.M,self.K),dtype=numpy.int)
self.ndsum = numpy.zeros((self.M,1),dtype=numpy.int)
# 根据self.Z进行更新,更新self.nd[m, k]和self.ndsum[m, 0]
forminrange(self.M):
forkinself.Z[m]:
self.nd[m,k] +=1
self.ndsum[m,0] =len(self.Z[m])
return
definit_statistics_word(self):
"""
:key: 初始化关于word的统计计数。先决条件: self.V, self.K, self.Z, self.arts_Z
"""
assertself.V >0andself.K >0andself.Zandself.arts_Z
# 统计计数初始化
self.nw = numpy.zeros((self.K,self.V),dtype=numpy.int)
self.nwsum = numpy.zeros((self.K,1),dtype=numpy.int)
# 根据self.Z进行更新,更新self.nw[k, w]和self.nwsum[k, 0]
forminrange(self.M):
fork,winzip(self.Z[m],self.arts_Z[m]):
self.nw[k,w] +=1
self.nwsum[k,0] +=1
return
definit_statistics(self):
"""
:key: 初始化全部的统计计数。上两个函数的综合函数。
"""
self.init_statistics_document()
self.init_statistics_word()
return
defsum_alpha_beta(self):
"""
:key: 计算alpha、beta的和
"""
self.sum_alpha =self.alpha.sum()
self.sum_beta =self.beta.sum()
return
defcalculate_theta(self):
"""
:key: 初始化并计算模型的theta值(M*K),用到alpha值
"""
assertself.sum_alpha >0
self.theta = (self.nd +self.alpha) / (self.ndsum +self.sum_alpha)
return
defcalculate_phi(self):
"""
:key: 初始化并计算模型的phi值(K*V),用到beta值
"""
assertself.sum_beta >0
self.phi = (self.nw +self.beta) / (self.nwsum +self.sum_beta)
return
# ---------------------------------------------计算Perplexity值------------------------------------------------------
defcalculate_perplexity(self):
"""
:key: 计算Perplexity值,并返回
"""
# 计算theta和phi值
self.calculate_theta()
self.calculate_phi()
# 开始计算
preplexity =0.0
forminrange(self.M):
forwinself.arts_Z[m]:
preplexity += numpy.log(numpy.sum(self.theta[m] *self.phi[:,w]))
returnnumpy.exp(-(preplexity /self.words_count))
# --------------------------------------------------静态函数---------------------------------------------------------
@staticmethod
defmultinomial_sample(pro_list):
"""
:key: 静态函数,多项式分布抽样,此时会改变pro_list的值
:parampro_list: [0.2, 0.7, 0.4, 0.1],此时说明返回下标1的可能性大,但也不绝对
"""
# 将pro_list进行累加
forkinrange(1,len(pro_list)):
pro_list[k] += pro_list[k-1]
# 确定随机数 u 落在哪个下标值,此时的下标值即为抽取的类别（random.rand()返回: [0, 1.0)）
u = numpy.random.rand() * pro_list[-1]
return_index =len(pro_list) -1
fortinrange(len(pro_list)):
ifpro_list[t] > u:
return_index = t
break
returnreturn_index
# ----------------------------------------------Gibbs抽样算法--------------------------------------------------------
defgibbs_sampling(self,is_calculate_preplexity):
"""
:key: LDA模型中的Gibbs抽样过程
:paramis_calculate_preplexity: 是否计算preplexity值
"""
# 计算preplexity值用到的变量
pp_list = []
pp_var = numpy.inf
# 开始迭代
last_iter =self.current_iter +1
iters_num =self.iters_numifself.iters_num !="auto"elseMAX_ITER_NUM
forself.current_iterinrange(last_iter,last_iter+iters_num):
info ="......"
# 是否计算preplexity值
ifis_calculate_preplexity:
pp =self.calculate_perplexity()
pp_list.append(pp)
# 计算列表最新VAR_NUM项的方差
pp_var = numpy.var(pp_list[-VAR_NUM:])iflen(pp_list) >= VAR_NUMelsenumpy.inf
info = (", preplexity: "+str(pp)) + ((", var: "+str(pp_var))iflen(pp_list) >= VAR_NUMelse"")
# 输出Debug信息
logging.debug("\titeration "+str(self.current_iter) + info)
# 判断是否跳出循环
ifself.iters_num =="auto"andpp_var < (VAR_NUM /2):
break
# 对每篇article的每个word进行一次抽样,抽取合适的k值
forminrange(self.M):
forninrange(len(self.Z[m])):
w =self.arts_Z[m][n]
k =self.Z[m][n]
# 统计计数减一
self.nd[m,k] -=1
self.ndsum[m,0] -=1
self.nw[k,w] -=1
self.nwsum[k,0] -=1
ifself.prior_wordand(winself.prior_word):
# 带有先验知识,否则进行正常抽样
k = numpy.random.choice(self.prior_word[w])
else:
# 计算theta值--下边的过程为抽取第m篇article的第n个词w的topic,即新的k
theta_p = (self.nd[m] +self.alpha) / (self.ndsum[m,0] +self.sum_alpha)
# 计算phi值--判断是训练模型,还是推断模型（注意self.beta[w_g]）
ifself.local_2_globalandself.train_model:
w_g =self.local_2_global[w]
phi_p = (self.train_model.nw[:,w_g] +self.nw[:,w] +self.beta[w_g]) / \
(self.train_model.nwsum[:,0] +self.nwsum[:,0] +self.sum_beta)
else:
phi_p = (self.nw[:,w] +self.beta[w]) / (self.nwsum[:,0] +self.sum_beta)
# multi_p为多项式分布的参数,此时没有进行标准化
multi_p = theta_p * phi_p
# 此时的topic即为Gibbs抽样得到的topic,它有较大的概率命中多项式概率大的topic
k = LdaBase.multinomial_sample(multi_p)
# 统计计数加一
self.nd[m,k] +=1
self.ndsum[m,0] +=1
self.nw[k,w] +=1
self.nwsum[k,0] +=1
# 更新Z值
self.Z[m][n] = k
# 抽样完毕
return
# -----------------------------------------Model数据存储、读取相关函数-------------------------------------------------
defsave_parameter(self,file_name):
"""
:key: 保存模型相关参数数据,包括: topics_num, M, V, K, words_count, alpha, beta
"""
withopen(file_name,"w",encoding="utf-8")asf_param:
foritemin["topics_num","M","V","K","words_count"]:
f_param.write("%s\t%s\n"% (item,str(self.__dict__[item])))
f_param.write("alpha\t%s\n"%",".join([str(item)foriteminself.alpha]))
f_param.write("beta\t%s\n"%",".join([str(item)foriteminself.beta]))
return
defload_parameter(self,file_name):
"""
:key: 加载模型相关参数数据,和上一个函数相对应
"""
withopen(file_name,"r",encoding="utf-8")asf_param:
forlineinf_param:
key,value = line.strip().split()
ifkeyin["topics_num","M","V","K","words_count"]:
self.__dict__[key] =int(value)
elifkeyin["alpha","beta"]:
self.__dict__[key] = numpy.array([float(item)foriteminvalue.split(",")])
return
defsave_zvalue(self,file_name):
"""
:key: 保存模型关于article的变量,包括: arts_Z, Z, artids_list等
"""
withopen(file_name,"w",encoding="utf-8")asf_zvalue:
forminrange(self.M):
out_line = [str(w) +":"+str(k)forw,kinzip(self.arts_Z[m],self.Z[m])]
f_zvalue.write(self.artids_list[m] +"\t"+" ".join(out_line) +"\n")
return
defload_zvalue(self,file_name):
"""
:key: 读取模型的Z变量。和上一个函数相对应
"""
self.arts_Z = []
self.artids_list = []
self.Z = []
withopen(file_name,"r",encoding="utf-8")asf_zvalue:
forlineinf_zvalue:
frags = line.strip().split()
art_id = frags[0].strip()
w_k_list = [value.split(":")forvalueinfrags[1:]]
# 添加到类中
self.artids_list.append(art_id)
self.arts_Z.append([int(item[0])foriteminw_k_list])
self.Z.append([int(item[1])foriteminw_k_list])
return
defsave_twords(self,file_name):
"""
:key: 保存模型的twords数据,要用到phi的数据
"""
self.calculate_phi()
out_num =self.Vifself.twords_num >self.Velseself.twords_num
withopen(file_name,"w",encoding="utf-8")asf_twords:
forkinrange(self.K):
words_list =sorted([(w,self.phi[k,w])forwinrange(self.V)],key=lambdax: x[1],reverse=True)
f_twords.write("Topic %dth:\n"% k)
f_twords.writelines(["\t%s %f\n"% (self.local_bi.get_value(w),p)forw,pinwords_list[:out_num]])
return
defload_twords(self,file_name):
"""
:key: 加载模型的twords数据,即先验数据
"""
self.prior_word.clear()
topic = -1
withopen(file_name,"r",encoding="utf-8")asf_twords:
forlineinf_twords:
ifline.startswith("Topic"):
topic =int(line.strip()[6:-3])
else:
word_id =self.local_bi.get_key(line.strip().split()[0].strip())
self.prior_word[word_id].append(topic)
return
defsave_tag(self,file_name):
"""
:key: 输出模型最终给数据打标签的结果,用到theta值
"""
self.calculate_theta()
withopen(file_name,"w",encoding="utf-8")asf_tag:
forminrange(self.M):
f_tag.write("%s\t%s\n"% (self.artids_list[m]," ".join([str(item)foriteminself.theta[m]])))
return
defsave_model(self):
"""
:key: 保存模型数据
"""
name_predix ="%s-%05d"% (self.model_name,self.current_iter)
# 保存训练结果
self.save_parameter(os.path.join(self.dir_path,"%s.%s"% (name_predix,"param")))
self.save_wordmap(os.path.join(self.dir_path,"%s.%s"% (name_predix,"wordmap")))
self.save_zvalue(os.path.join(self.dir_path,"%s.%s"% (name_predix,"zvalue")))
#保存额外数据
self.save_twords(os.path.join(self.dir_path,"%s.%s"% (name_predix,"twords")))
self.save_tag(os.path.join(self.dir_path,"%s.%s"% (name_predix,"tag")))
return
defload_model(self):
"""
:key: 加载模型数据
"""
name_predix ="%s-%05d"% (self.model_name,self.current_iter)
# 加载训练结果
self.load_parameter(os.path.join(self.dir_path,"%s.%s"% (name_predix,"param")))
self.load_wordmap(os.path.join(self.dir_path,"%s.%s"% (name_predix,"wordmap")))
self.load_zvalue(os.path.join(self.dir_path,"%s.%s"% (name_predix,"zvalue")))
return
classLdaModel(LdaBase):
"""
LDA模型定义,主要实现训练、继续训练、推断的过程
"""
definit_train_model(self,dir_path,model_name,current_iter,iters_num=None,topics_num=10,twords_num=200,
alpha=-1.0,beta=0.01,data_file="",prior_file=""):
"""
:key: 初始化训练模型,根据参数current_iter（是否等于0）决定是初始化新模型,还是加载已有模型
:key: 当初始化新模型时,除了prior_file先验文件外,其余所有的参数都需要,且current_iter等于0
:key: 当加载已有模型时,只需要dir_path, model_name, current_iter（不等于0）, iters_num, twords_num即可
:paramiters_num: 可以为整数值或者“auto”
"""
ifcurrent_iter ==0:
logging.debug("init a new train model")
# 初始化语料集
self.init_corpus_with_file(data_file)
# 初始化部分变量
self.dir_path = dir_path
self.model_name = model_name
self.current_iter = current_iter
self.iters_num = iters_num
self.topics_num = topics_num
self.K = topics_num
self.twords_num = twords_num
# 初始化alpha和beta
self.alpha = numpy.array([alphaifalpha >0else(50.0/self.K)forkinrange(self.K)])
self.beta = numpy.array([betaifbeta >0else0.01forwinrange(self.V)])
# 初始化Z值,以便统计计数
self.Z = [[numpy.random.randint(self.K)forninrange(len(self.arts_Z[m]))]forminrange(self.M)]
else:
logging.debug("init an existed model")
# 初始化部分变量
self.dir_path = dir_path
self.model_name = model_name
self.current_iter = current_iter
self.iters_num = iters_num
self.twords_num = twords_num
# 加载已有模型
self.load_model()
# 初始化统计计数
self.init_statistics()
# 计算alpha和beta的和值
self.sum_alpha_beta()
# 初始化先验知识
ifprior_file:
self.load_twords(prior_file)
# 返回该模型
returnself
defbegin_gibbs_sampling_train(self,is_calculate_preplexity=True):
"""
:key: 训练模型,对语料集中的所有数据进行Gibbs抽样,并保存最后的抽样结果
"""
# Gibbs抽样
logging.debug("sample iteration start, iters_num: "+str(self.iters_num))
self.gibbs_sampling(is_calculate_preplexity)
logging.debug("sample iteration finish")
# 保存模型
logging.debug("save model")
self.save_model()
return
definit_inference_model(self,train_model):
"""
:key: 初始化推断模型
"""
self.train_model = train_model
# 初始化变量: 主要用到self.topics_num, self.K
self.topics_num = train_model.topics_num
self.K = train_model.K
# 初始化变量self.alpha, self.beta,直接沿用train_model的值
self.alpha = train_model.alpha# K维的float值,训练和推断模型中的K相同,故可以沿用
self.beta = train_model.beta# V维的float值,推断模型中用于计算phi的V值应该是全局的word的数量,故可以沿用
self.sum_alpha_beta()# 计算alpha和beta的和
# 初始化数据集的self.global_bi
self.global_bi = train_model.local_bi
return
definference_data(self,article_list,iters_num=100,repeat_num=3):
"""
:key: 利用现有模型推断数据
:paramarticle_list: 每一行的数据格式为: id[tab]word1 word2 word3......
:paramiters_num: 每一次迭代的次数
:paramrepeat_num: 重复迭代的次数
"""
# 初始化语料集
self.init_corpus_with_articles(article_list)
# 初始化返回变量
return_theta = numpy.zeros((self.M,self.K))
# 重复抽样
foriinrange(repeat_num):
logging.debug("inference repeat_num: "+str(i+1))
# 初始化变量
self.current_iter =0
self.iters_num = iters_num
# 初始化Z值,以便统计计数
self.Z = [[numpy.random.randint(self.K)forninrange(len(self.arts_Z[m]))]forminrange(self.M)]
# 初始化统计计数
self.init_statistics()
# 开始推断
self.gibbs_sampling(is_calculate_preplexity=False)
# 计算theta
self.calculate_theta()
return_theta +=self.theta
# 计算结果,并返回
returnreturn_theta / repeat_num
if__name__ =="__main__":
"""
测试代码
"""
logging.basicConfig(level=logging.DEBUG,format="%(asctime)s\t%(levelname)s\t%(message)s")
# train或者inference
test_type ="train"
# test_type = "inference"
# 测试新模型
iftest_type =="train":
model = LdaModel()
# 由prior_file决定是否带有先验知识
model.init_train_model("/root/py_dir/lda_python_native/","model",current_iter=0,iters_num="auto",topics_num=10,data_file="/root/py_dir/lda_python_native/sba_bu.txt")
# model.init_train_model("data/", "model", current_iter=0, iters_num="auto", topics_num=10, data_file="corpus.txt", prior_file="prior.twords")
model.begin_gibbs_sampling_train()
eliftest_type =="inference":
model = LdaModel()
model.init_inference_model(LdaModel().init_train_model("data/","model",current_iter=134))
data = [
"cn 咪咕 漫画 咪咕 漫画 漫画 更名 咪咕 漫画 资源 偷星 国漫 全彩 日漫 实时 在线看 随心所欲 登陆 漫画 资源 黑白 全彩 航海王",
"co aircloud aircloud 硬件 设备 wifi 智能 手要 平板电脑 电脑 存储 aircloud 文件 远程 型号 aircloud 硬件 设备 wifi"
]
result = model.inference_data(data)
# 退出程序
exit()