CiteSpace主题聚类技术解析：从算法原理到实践应用

1次阅读

没有评论

共计 3798 个字符，预计需要花费 10 分钟才能阅读完成。

在科研文献分析中，主题聚类是理解领域发展脉络的关键技术。但实际操作中常遇到以下问题：

高维稀疏性 ：文献关键词矩阵通常维度极高（数万维），但单个文档仅包含少量关键词，导致传统聚类算法效果不佳
语义噪声 ：同义词（如 ”AI” 和 ” 人工智能 ”）、缩写词（如 ”NLP” 和 ” 自然语言处理 ”）未规范统一
时效偏差 ：新兴领域术语可能被传统聚类方法忽略
跨学科干扰 ：交叉学科文献包含多个领域的术语，导致主题边界模糊

优点：概率生成模型，能发现潜在语义
局限：需要预设主题数，对短文本效果差

优点：计算简单，实现快速
局限：无法捕捉词序信息，忽视术语共现关系

共词网络分析 ：通过术语共现构建语义网络
突发检测 ：识别突然增长的研究热点
时序切片 ：支持学科演进过程的可视化追踪

术语提取：采用 Noun Phrase 识别技术
构建共现矩阵：统计窗口大小为 5 的术语共现
标准化处理：使用 Salton 余弦相似度归一化

import numpy as np
from sklearn.feature_extraction.text import CountVectorizer

def build_cooccurrence(docs, window_size=5):
    """
    构建术语共现矩阵
    :param docs: 分词后的文档列表
    :param window_size: 共现窗口大小
    :return: 共现矩阵 (co_mat), 词汇表 (vocab)
    """
    vectorizer = CountVectorizer(analyzer=lambda x: x)
    X = vectorizer.fit_transform(docs)
    vocab = vectorizer.get_feature_names_out()

    co_mat = np.zeros((len(vocab), len(vocab)))
    for doc in docs:
        for i in range(len(doc)):
            for j in range(i+1, min(i+window_size, len(doc))):
                idx_i = vectorizer.vocabulary_[doc[i]]
                idx_j = vectorizer.vocabulary_[doc[j]]
                co_mat[idx_i, idx_j] += 1
                co_mat[idx_j, idx_i] += 1

    # Salton 余弦标准化
    diag = np.diag(co_mat)
    norm_mat = co_mat / np.sqrt(np.outer(diag, diag) + 1e-8)
    return norm_mat, vocab

采用 Kleinberg 爆发检测模型，通过有限状态自动机识别术语频率的突变：

from scipy.stats import poisson

def detect_bursts(term_counts, r=2, s=1):
    """
    Kleinberg 突发检测算法
    :param term_counts: 术语在各时间片的出现次数
    :param r: 状态转移代价参数
    :param s: 平滑参数
    :return: 突发得分序列
    """
    n = len(term_counts)
    mean = sum(term_counts)/n

    # 状态转移成本矩阵
    cost = np.zeros((2, n))
    cost[1, 0] = -np.log(poisson.pmf(term_counts[0], s*mean))

    for t in range(1, n):
        # 低状态转移
        cost[0, t] = min(cost[0, t-1], cost[1, t-1] + r) 
        cost[0, t] += -np.log(poisson.pmf(term_counts[t], mean))

        # 高状态转移
        cost[1, t] = min(cost[0, t-1] + r, cost[1, t-1])
        cost[1, t] += -np.log(poisson.pmf(term_counts[t], s*mean))

    # 回溯状态序列
    states = np.zeros(n, dtype=int)
    states[-1] = np.argmin(cost[:, -1])
    for t in range(n-2, -1, -1):
        if states[t+1] == 0:
            states[t] = 0 if cost[0,t] < cost[1,t] + r else 1
        else:
            states[t] = 0 if cost[0,t] + r < cost[1,t] else 1

    return states

import pandas as pd
import nltk
from nltk.corpus import stopwords

class TextPreprocessor:
    def __init__(self):
        self.stopwords = set(stopwords.words('english'))
        self.stemmer = nltk.stem.PorterStemmer()

    def process(self, text):
        # 分词与词性标注
        tokens = nltk.word_tokenize(text.lower())
        tagged = nltk.pos_tag(tokens)

        # 提取名词短语
        grammar = "NP: {<JJ>*<NN.*>+}"
        cp = nltk.RegexpParser(grammar)
        tree = cp.parse(tagged)

        # 提取术语并去停用词
        terms = []
        for subtree in tree.subtrees():
            if subtree.label() == 'NP':
                term = ' '.join(word for word, pos in subtree.leaves() 
                               if word not in self.stopwords)
                terms.append(self.stemmer.stem(term))

        return terms

from sklearn.cluster import SpectralClustering
from scipy.sparse import csr_matrix

class CiteSpaceCluster:
    def __init__(self, n_clusters=10, affinity='cosine'):
        self.n_clusters = n_clusters
        self.affinity = affinity

    def fit(self, co_mat):
        # 稀疏矩阵优化
        sparse_mat = csr_matrix(co_mat)

        # 谱聚类
        model = SpectralClustering(
            n_clusters=self.n_clusters,
            affinity=self.affinity,
            assign_labels='discretize'
        )
        labels = model.fit_predict(sparse_mat)

        # 模块度评估
        q_score = self._modularity(co_mat, labels)
        return labels, q_score

    def _modularity(self, mat, labels):
        """计算模块度 Q 值"""
        m = np.sum(mat)
        q = 0
        for c in set(labels):
            idx = np.where(labels == c)[0]
            sub_mat = mat[idx][:, idx]
            in_degree = np.sum(sub_mat)
            all_degree = np.sum(mat[idx])
            q += in_degree/m - (all_degree/m)**2
        return q

稀疏矩阵存储 ：当术语数超过 5000 时，使用 scipy.sparse.csr_matrix
近似计算 ：对大规模矩阵采用 Nystrom 方法近似谱分解

并行计算 ：

from joblib import Parallel, delayed

def parallel_cooccurrence(docs, n_jobs=4):
    chunk_size = len(docs) // n_jobs
    results = Parallel(n_jobs=n_jobs)(delayed(partial_cooccurrence)(docs[i*chunk_size:(i+1)*chunk_size])
        for i in range(n_jobs)
    )
    return sum(results)