LDA主题模型简介及Python实现

杨利霞

LDA主题模型简介及Python实现

一、LDA主题模型简介
        LDA主题模型主要用于推测文档的主题分布，可以将文档集中每篇文档的主题以概率分布的形式给出根据主题进行主题聚类或文本分类。

$ f! a6 @" z0 ^; m" x+ A        LDA主题模型不关心文档中单词的顺序，通常使用词袋特征（bag-of-word feature）来代表文档。词袋模型介绍可以参考这篇文章：文本向量化表示——词袋模型 - 知乎
) s" {/ {* I, T* p& \1 w; j& ^/ Q
        了解LDA模型，我们需要先了解LDA的生成模型，LDA认为一篇文章是怎么形成的呢？

$ D5 o4 H: ^0 Z; ~/ R) \        LDA模型认为主题可以由一个词汇分布来表示，而文章可以由主题分布来表示。

        比如有两个主题，美食和美妆。LDA说两个主题可以由词汇分布表示，他们分别是：

% `% p$ A# ]7 x/ H0 [" O; m, i  T{面包：0.4，火锅：0.5，眉笔：0.03，腮红：0.07}
{眉笔：0.4，腮红：0.5，面包：0.03，火锅：0.07}
- O# J! P. _' q) b; R; c! Q/ V
. `8 d$ b+ K% n. b        同样，对于两篇文章，LDA认为文章可以由主题分布这么表示：
( a( U  k. C! W% u0 p
" [  Q& ?% H8 t7 d6 W《美妆日记》{美妆：0.8，美食：0.1，其他：0.1}

: d& \* X; \5 {9 i) ^4 Z《美食探索》{美食：0.8，美妆：0.1，其他：0.1}
2 u3 K- p8 F9 i  S7 o
+ {2 W; t! e' Z; D% V1 {1 w        所以想要生成一篇文章，可以先以一定的概率选取上述某个主题，再以一定的概率选取那个主题下的某个单词，不断重复这两步就可以生成最终文章。
1 t$ h9 Z3 y9 K7 u6 f( }  l/ _
        在LDA模型中，一篇文档生成的方式如下：
& V5 p* \: I+ V


        其中，类似Beta分布是二项式分布的共轭先验概率分布，而狄利克雷分布（Dirichlet分布）是多项式分布的共轭先验概率分布。
; Z! e2 F* P- `" h+ ^3 P" w& @8 Z
, @3 U7 W: X' q: G5 D: E# c& z  f

        如果我们要生成一篇文档，它里面的每个词语出现的概率为：
: L& R& [3 R8 g0 H
0 g$ `$ J! {7 D9 O% \/ H% P9 V
& _% ]* A! V8 v, }
2 g" V; v/ f0 j( E7 v7 {9 P+ u& U         更详细的数学推导可以见：通俗理解LDA主题模型_结构之法 算法之道-CSDN博客_lda模型
4 y' d6 G* _! g$ X0 F
        看到文章推断其隐藏的主题分布，就是建模的目的。换言之，人类根据文档生成模型写成了各类文章，然后丢给了计算机，相当于计算机看到的是一篇篇已经写好的文章。现在计算机需要根据一篇篇文章中看到的一系列词归纳出当篇文章的主题，进而得出各个主题各自不同的出现概率：主题分布。
; L* ?2 r, q3 N5 m; z
1 y) c4 O/ G7 c        至于LDA主题模型在计算机中具体是怎么实现的，我们也可以不必细究，现在有很多可以直接用来进行LDA主题分析的包，我们直接用就行。（没错，我就是调包侠）

" ^, Y7 A3 ?& o8 ?* j二、Python实现
4 H# ^+ S1 \# m5 _4 Y        在用Python进行LDA主题模型分析之前，我先对文档进行了分词和去停用词处理（详情可以看我之前的文章：用python对单一微博文档进行分词——jieba分词（加保留词和停用词）_阿丢是丢心心的博客-CSDN博客_jieba 停用词）

7 N. M" [8 V+ d2 M: I        我下面的输入文件也是已经分好词的文件
& B" `5 `: q- y
* K! n! G; q( z7 o1.导入算法包
import gensim
$ ^1 [, n- x! R6 x" Y( `from gensim import corpora
* X( F3 h# `2 i5 {0 H- Bimport matplotlib.pyplot as plt
import matplotlib
9 R3 K$ }5 Y. E2 |import numpy as np
import warnings
warnings.filterwarnings('ignore')  # To ignore all warnings that arise here to enhance clarity

- S! N6 F) V6 |4 kfrom gensim.models.coherencemodel import CoherenceModel
from gensim.models.ldamodel import LdaModel
2.加载数据
        先将文档转化为一个二元列表，其中每个子列表代表一条微博：
1 C. b2 v, L9 S  D
% v# ~$ V- ]. ~% R, ^7 Y& J- L, NPATH = "E:/data/output.csv"
) U- ~4 t7 j% ^4 P( c! g: ]
- E' o: y  P- r% \9 Y$ Mfile_object2=open(PATH,encoding = 'utf-8',errors = 'ignore').read().split('\n')  #一行行的读取内容
! \) M+ C# ?3 \  W4 z% Rdata_set=[]  #建立存储分词的列表
for i in range(len(file_object2)):
% @& w+ |: O( W, Z/ P+ B$ L# d- r    result=[]
& |) {- V$ X7 i4 r, ]+ K$ O3 q    seg_list = file_object2.split()
    for w in seg_list :  #读取每一行分词
        result.append(w)
3 O( i) f) f4 W: r. z; ~6 g    data_set.append(result)
print(data_set)
  Y1 w# I( y% V: _: i" y5 Q        构建词典，语料向量化表示：
8 U3 d! f7 s4 B7 P- o
, _6 z4 u: ~8 r5 W4 Y2 Idictionary = corpora.Dictionary(data_set)  # 构建词典
# T+ Y( \0 L. _- s  p6 P3 Pcorpus = [dictionary.doc2bow(text) for text in data_set]  #表示为第几个单词出现了几次
3.构建LDA模型
ldamodel = LdaModel(corpus, num_topics=10, id2word = dictionary, passes=30,random_state = 1)   #分为10个主题
' f+ h# `9 D  e, A1 e3 ?print(ldamodel.print_topics(num_topics=num_topics, num_words=15))  #每个主题输出15个单词
        这是确定主题数时LDA模型的构建方法，一般我们可以用指标来评估模型好坏，也可以用这些指标来确定最优主题数。一般用来评价LDA主题模型的指标有困惑度（perplexity）和主题一致性（coherence），困惑度越低或者一致性越高说明模型越好。一些研究表明perplexity并不是一个好的指标，所以一般我用coherence来评价模型并选择最优主题，但下面代码两种方法我都用了。

#计算困惑度
def perplexity(num_topics):
9 L3 Z0 r, o: }$ I/ V2 c( r% n    ldamodel = LdaModel(corpus, num_topics=num_topics, id2word = dictionary, passes=30)
    print(ldamodel.print_topics(num_topics=num_topics, num_words=15))
    print(ldamodel.log_perplexity(corpus))
    return ldamodel.log_perplexity(corpus)
#计算coherence
def coherence(num_topics):
    ldamodel = LdaModel(corpus, num_topics=num_topics, id2word = dictionary, passes=30,random_state = 1)
7 Y5 A0 L- q9 K2 X% D1 P    print(ldamodel.print_topics(num_topics=num_topics, num_words=10))
; X- M7 L# }! X! F; M  K% z. M1 T    ldacm = CoherenceModel(model=ldamodel, texts=data_set, dictionary=dictionary, coherence='c_v')
, K8 G( _6 u3 k' j# [    print(ldacm.get_coherence())
# s6 O; q* J: r) j. b    return ldacm.get_coherence()
( v: E/ H* x  @! S% d0 D5 `3 N4.绘制主题-coherence曲线，选择最佳主题数
x = range(1,15)
# _! {+ I- E+ V# z = [perplexity(i) for i in x]  #如果想用困惑度就选这个
! w1 m. Q8 b4 K7 c6 c& Dy = [coherence(i) for i in x]
. c# Q3 @; a8 K1 ?: a2 C5 |/ l$ O3 Mplt.plot(x, y)
4 E! S8 _' i/ h: R$ N: c5 Aplt.xlabel('主题数目')
plt.ylabel('coherence大小')
: p% J* j0 y- Splt.rcParams['font.sans-serif']=['SimHei']
7 I2 F) g8 q2 E6 Ematplotlib.rcParams['axes.unicode_minus']=False
plt.title('主题-coherence变化情况')
7 y* Z3 w6 z* |9 M0 ~7 mplt.show()
5 |) M0 Y  D' V2 ~0 j        最终能得到各主题的词语分布和这样的图形：

# }5 @; c8 _5 [' l2 F
! W3 P- a5 r  H; Z. |' j
5.结果输出与可视化
7 R) d* j" a. y% d8 G( ]        通过上述主题评估，我们发现可以选择5作为主题个数，接下来我们可以再跑一次模型，设定主题数为5，并输出每个文档最有可能对应的主题

8 f1 l. z5 a# {5 i6 l6 U8 nfrom gensim.models import LdaModel
2 c6 s: T) S" G1 O5 B- {import pandas as pd
from gensim.corpora import Dictionary
from gensim import corpora, models
import csv

# 准备数据
, j8 |; s& P9 r* K* MPATH = "E:/data/output1.csv"
  P) o1 m; L: v/ Y- N. c, n; r
file_object2=open(PATH,encoding = 'utf-8',errors = 'ignore').read().split('\n')  #一行行的读取内容
5 l, m  s" h, Q1 h; Udata_set=[] #建立存储分词的列表
' p7 ?# I' I" t- [2 Jfor i in range(len(file_object2)):
6 x; B7 X# ^6 M: k) @    result=[]
3 H' p6 q: v' V3 Q6 H. `- G    seg_list = file_object2.split()
    for w in seg_list :#读取每一行分词
        result.append(w)
/ M( r6 W. |# i' @9 U; H, R$ _# p    data_set.append(result)
. }6 _* k- @% l& r" L- ~
# Y7 P+ h6 g# Jdictionary = corpora.Dictionary(data_set)  # 构建词典
% d/ @' ?1 g6 D. M$ z% g/ k1 _, d) c3 Vcorpus = [dictionary.doc2bow(text) for text in data_set]
3 x1 `6 ^1 j% n$ Z( c: R  m
lda = LdaModel(corpus=corpus, id2word=dictionary, num_topics=5, passes = 30,random_state=1)
# h/ [4 b! [- \2 @( [topic_list=lda.print_topics()
print(topic_list)
$ }2 [4 |, I' _5 k) J
for i in lda.get_document_topics(corpus)[:]:
    listj=[]
    for j in i:
        listj.append(j[1])
    bz=listj.index(max(listj))
    print(i[bz][0])

        同时我们可以用pyLDAvis对LDA模型结果进行可视化：
4 j5 B" X0 \, u" {8 c
# x. j+ r( [" J& @' Zimport pyLDAvis.gensim
pyLDAvis.enable_notebook()
" b# a0 o5 l1 s2 i7 udata = pyLDAvis.gensim.prepare(lda, corpus, dictionary)
- C' N/ V! Z5 r, ~1 q# w" QpyLDAvis.save_html(data, 'E:/data/3topic.html')
" A5 s/ R9 l$ A% M$ h! [) Z; F        大概能得到这样的结果：

+ D; f$ x2 z$ I; u8 u$ M' f

左侧圆圈表示主题，右侧表示各个词语对主题的贡献度。
' W! ~3 {9 e, v  s. j& O
8 |  {6 F7 k( p& ^所有代码如下：
import gensim
# K0 T  o2 q5 @% V  g) dfrom gensim import corpora
  a3 T0 j: u- ~5 aimport matplotlib.pyplot as plt
import matplotlib
' e8 v# M3 w* Himport numpy as np
import warnings
8 j& F" q% ?. z% n2 ~warnings.filterwarnings('ignore')  # To ignore all warnings that arise here to enhance clarity
6 b+ _& d4 o  Z) R# i
  G' ]' V4 z1 K/ B1 Lfrom gensim.models.coherencemodel import CoherenceModel
from gensim.models.ldamodel import LdaModel
  \) b* H1 E7 |7 l


" y  q8 O) Z( s& @9 Q6 e4 o- J # 准备数据
" {1 F) R* }/ hPATH = "E:/data/output.csv"
  \) ?% d9 p: F/ ^& {! C' V
0 ~4 |. i5 ^  L# C; _9 z3 T/ b+ ?1 n; I+ Sfile_object2=open(PATH,encoding = 'utf-8',errors = 'ignore').read().split('\n')  #一行行的读取内容
data_set=[] #建立存储分词的列表
: y4 g, q  b; v8 Q% x2 d, a6 T  Tfor i in range(len(file_object2)):
    result=[]
    seg_list = file_object2.split()
" O. o( Z4 i6 m2 N. I/ ?    for w in seg_list :#读取每一行分词
        result.append(w)
    data_set.append(result)
print(data_set)
" L3 A/ p& W6 O
0 Y6 T- O* a% O# r* }) }. c' r
  _; j+ B+ |$ g1 b& t9 Udictionary = corpora.Dictionary(data_set)  # 构建 document-term matrix
' J( M' Z. U6 d! M) Lcorpus = [dictionary.doc2bow(text) for text in data_set]
3 ^- |: Q( A: T: c* F: G$ ]+ X#Lda = gensim.models.ldamodel.LdaModel  # 创建LDA对象

4 s' w6 H6 |# W+ _/ A! ?$ L5 s+ x( G#计算困惑度
/ x! v- u- E6 G1 W" Wdef perplexity(num_topics):
2 `6 G' P- O! G. B4 Y    ldamodel = LdaModel(corpus, num_topics=num_topics, id2word = dictionary, passes=30)
8 x4 G6 I0 t( ^7 K" j* {    print(ldamodel.print_topics(num_topics=num_topics, num_words=15))
    print(ldamodel.log_perplexity(corpus))
3 z8 ]2 @3 y& b, a9 D0 B    return ldamodel.log_perplexity(corpus)
& [2 }: l9 F/ }8 Q" b( {# ]0 Q( U- _- ?* b
/ F0 ~9 c5 K+ b5 e5 m0 O7 C#计算coherence
/ ^+ ~3 D& O. w% Sdef coherence(num_topics):
    ldamodel = LdaModel(corpus, num_topics=num_topics, id2word = dictionary, passes=30,random_state = 1)
: j2 T5 i. Z4 S6 p' U: S    print(ldamodel.print_topics(num_topics=num_topics, num_words=10))
    ldacm = CoherenceModel(model=ldamodel, texts=data_set, dictionary=dictionary, coherence='c_v')
    print(ldacm.get_coherence())
6 v* Z. X  E: ?7 S4 E" V9 m    return ldacm.get_coherence()

# 绘制困惑度折线图
& p$ ~* w  B, u0 E% ^x = range(1,15)
! O% V1 ^( d9 G' S8 q' c# z = [perplexity(i) for i in x]
2 J: ?. x$ }: n' v1 v4 f& Hy = [coherence(i) for i in x]
plt.plot(x, y)
9 Z2 Z3 p: o% M' d. y1 ^0 X9 K/ ^plt.xlabel('主题数目')
, W% k5 g. y: @) m4 t+ I  qplt.ylabel('coherence大小')
+ n, {' L  a' X. W  [/ Splt.rcParams['font.sans-serif']=['SimHei']
: i+ ^  y- ^# j* smatplotlib.rcParams['axes.unicode_minus']=False
4 B' X/ F& C6 W5 a# kplt.title('主题-coherence变化情况')
8 L+ K% A6 @0 @! Z3 `0 oplt.show()

from gensim.models import LdaModel
- G# H: j) L$ S! g! D" {1 C" |4 `' dimport pandas as pd
, j( s: w, o% k& A$ q$ L% \3 H, Vfrom gensim.corpora import Dictionary
/ b$ k# P; U9 N* j. T; [2 }from gensim import corpora, models
import csv
* {9 g4 Q* p/ L6 Z$ [- m3 L
) U6 p1 Z6 T: S- O# 准备数据
PATH = "E:/data/output1.csv"

+ j' b( M# U6 S8 t8 }3 afile_object2=open(PATH,encoding = 'utf-8',errors = 'ignore').read().split('\n')  #一行行的读取内容
data_set=[] #建立存储分词的列表
for i in range(len(file_object2)):
    result=[]
    seg_list = file_object2.split()
    for w in seg_list :#读取每一行分词
        result.append(w)
- M7 @. H3 E6 \1 ^  F$ F) {0 T    data_set.append(result)

. v& ]" f& l" a  `4 y$ jdictionary = corpora.Dictionary(data_set)  # 构建 document-term matrix
( C/ m7 v) \' }' ^6 M% ecorpus = [dictionary.doc2bow(text) for text in data_set]
" \4 h2 X! k; K7 n2 F0 V
lda = LdaModel(corpus=corpus, id2word=dictionary, num_topics=5, passes = 30,random_state=1)
topic_list=lda.print_topics()
print(topic_list)

result_list =[]
% m  m& v& L  Efor i in lda.get_document_topics(corpus)[:]:
9 }+ g6 ~( v' s  c+ T    listj=[]
7 x0 w( q2 J6 \( Q& C. @! q    for j in i:
        listj.append(j[1])
4 i  p2 n0 P5 ~5 `8 w    bz=listj.index(max(listj))
/ _5 Y: s$ A9 C/ K# `5 k) H, ~% C    result_list.append(i[bz][0])
print(result_list)

import pyLDAvis.gensim
pyLDAvis.enable_notebook()
data = pyLDAvis.gensim.prepare(lda, corpus, dictionary)
pyLDAvis.save_html(data, 'E:/data/topic.html')
有需要自取~
————————————————
版权声明：本文为CSDN博主「阿丢是丢心心」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_41168304/article/details/122389948


& f: l2 T& ?& I: s