当前位置:   article > 正文

LDA Part2: topic个数的选择(Coherence+Perplexity)_lda一致性和困惑度用哪个

lda一致性和困惑度用哪个

LDA Part2: topic个数的选择

目前比较成熟的判断一个LDA模型是否合理的标准一般有两个,一个是一致性,另一个是困惑度。

困惑度perplexity表示的对于一篇文章来说,我们有多不确定它是属于某个主题的。即主题的个数越多,模型的困惑度就越低,即主题的个数越多,模型的困惑度就越低,但是注意一点,当主题数很多的时候,生成的模型往往会过拟合,所以不能单纯依靠困惑度来判断一个模型的好坏。这时候我们的另一个判断标准就有作用了——一致性

一致性评估基于词语共现的频率,衡量了主题中词语之间的相关性。通过计算每个主题的一致性评分,并在不同主题数量下比较这些分数,可以找到使一致性评分最高的主题数量。

通常,一致性评估会随着主题数量的增加而增加,但在某个点之后会达到饱和状态,不再增加,这时候的主题数量可以被认为是最佳的选择。

Coherence:

Topic个数的选取,一致性角度(即两个词语的语境相关性)

#定义函数,计算在观察到词语word2的情况下,观察到词语word1的条件概率的对数值
def log_prob_see_word1_given_see_word2(word1, word2, feature_names, eps=0.1):#eps:一个小的正数,用于平滑计算,防止分母为0导致的数学错误
    word1_column_idx = tf_vectorizer.vocabulary_[word1]#获取字典中的列索引
    word2_column_idx = tf_vectorizer.vocabulary_[word2]#获取字典中的列索引
    documents_with_word1 = (tf[:, word1_column_idx].toarray().flatten() > 0)
    documents_with_word2 = (tf[:, word2_column_idx].toarray().flatten() > 0)
    documents_with_both_word1_and_word2 = documents_with_word1 * documents_with_word2
    return np.log2((documents_with_both_word1_and_word2.sum() + eps) / documents_with_word2.sum())
#利用这些索引,在稀疏矩阵 tf 中找出含有这两个词的文档。接着计算两个词共同出现的文档数,并用这个数目除以含有word2的文档总数来计算条件概率,最后返回这个概率的对数值。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
#定义函数计算所有主题的平均一致性,主题-词概率矩阵,每个主题中权重最高的词的数量,词汇表,打印详细信息
def compute_average_coherence(topic_word_probabilities, num_top_words, feature_names, verbose=True):
    num_topics = len(topic_word_probabilities) # 10个topic
    average_coherence = 0
    for topic_idx in range(num_topics): # 依次循环topic
        if verbose:
            print('[Topic ', topic_idx, ']', sep='')
        
        sort_indices = np.argsort(topic_word_probabilities[topic_idx])[::-1] # 回忆topic_word_distributions,k*v矩阵,每个topic中单词的权重是多少,np.argsort()[::-1] 返回从大到小的索引值,即topic中词权重最大的索引到最小的索引
        coherence = 0.#初始化 coherence 为0,用于累计当前主题的一致性得分
        for top_word_idx1 in sort_indices[:num_top_words]: # 选择对排名前20的词计算coherence
            word1 = feature_names[top_word_idx1] # 按index输出单词是什么
            for top_word_idx2 in sort_indices[:num_top_words]: # 选择第二个单词
                word2 = feature_names[top_word_idx2]
                if top_word_idx1 != top_word_idx2: # 排除相同单词,前20的每一对不同的word1和word2,计算它们的条件概率的对数值,并累加到 coherence
                    coherence += log_prob_see_word1_given_see_word2(word1, word2, feature_names, 0.1) # 依次计算并累加,在出现了word2的情况下,word1出现的概率,整体概率越高说明coherence越好
        
        if verbose:
            print('Coherence:', coherence) # 输出每个topic的总coherence
            print()
        average_coherence += coherence # 将不同Topic的coherence累加
    average_coherence /= num_topics # 累加的coherence求/Topic个数,得模型coherence的平均值
    if verbose:
        print('Average coherence:', average_coherence)
    return average_coherence
# 查看每个tpoic最可能的单词(概率大小排序),并试图用这些单词来解释不同主题对应的内容。
num_top_words = 20 # 概率大小排序后前20个词
compute_average_coherence(topic_word_probabilities, num_top_words, feature_names, True)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

将topic值依次循环,计算每个LDA模型的 average coherence,我们希望 average coherence 越大越好

k_values = range(2, 11) # 设置不同的主题数量,从2到10
avg_coherences = [] # 存储每种主题数量的平均一致性
avg_num_unique_words = []
num_top_words = 20 # 定义每个主题要显示的最多词数

for k in k_values: # 遍历不同的主题数量
    lda_candidate = LatentDirichletAllocation(n_components=k, random_state=0)
    lda_candidate.fit(tf) # 使用文档-词频矩阵tf拟合LDA模型
    # 计算每个主题的词概率分布
    topic_word_contributions = lda_candidate.components_
    topic_word_totals = topic_word_contributions.sum(axis=1)
    topic_word_probabilities = topic_word_contributions / topic_word_totals[:, np.newaxis]
    print('-' * 80)
    print('Number of topics:', k)
    print()
     # 打印每个主题的主要词汇及其概率
    print_top_words_probabilities(topic_word_probabilities, num_top_words, feature_names)
    print()
    print()
    
    avg_coherences.append(compute_average_coherence(topic_word_probabilities, num_top_words, feature_names, False))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
绘图可视化
plt.plot(k_values, avg_coherences)
plt.xlabel('Number of topics')
plt.ylabel('Average coherence')
  • 1
  • 2
  • 3

在这里插入图片描述

Perplexity

通过调包+循环的方式计算Perplexity

import numpy as np
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer

# 加载数据
data, _ = fetch_20newsgroups(shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'), return_X_y=True)
tf_vectorizer = CountVectorizer(max_df=0.95, min_df=2, max_features=1000, stop_words='english')
tf = tf_vectorizer.fit_transform(data)

# 设置主题数范围
topic_range = range(2, 31)#定义k值的范围
perplexity_scores = [] #初始化困惑度

for k in topic_range:
    lda = LatentDirichletAllocation(n_components=k, random_state=0)
    lda.fit(tf)
    perplexity = lda.perplexity(tf)
    perplexity_scores.append(perplexity)
    print(f"Number of topics: {k}, Perplexity: {perplexity}")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

在所有模型中找到具有最低困惑度的模型——评估结果

# 找到最低困惑度的主题数
min_perplexity = min(perplexity_scores)
optimal_topics = topic_range[perplexity_scores.index(min_perplexity)]
print(f"Optimal number of topics: {optimal_topics}, Minimum Perplexity: {min_perplexity}")
  • 1
  • 2
  • 3
  • 4

Perplexity困惑度可视化

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.plot(topic_range, perplexity_scores)
plt.title("LDA Perplexity vs. Number of Topics")
plt.xlabel("Number of Topics")
plt.ylabel("Perplexity")
plt.xticks(topic_range)
plt.grid(False)  # 设置为False来取消网格显示
plt.show()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在这里插入图片描述

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小蓝xlanll/article/detail/715372
推荐阅读
相关标签
  

闽ICP备14008679号