KL 散度(python+nlp)

python demo

KL 散度（Kullback-Leibler divergence），也称为相对熵，是衡量两个概率分布之间差异的一种方式。KL 散度是非对称的，也就是说，P 相对于 Q 的 KL 散度通常不等于 Q 相对于 P 的 KL 散度。

一个简单的 Python 类来计算两个离散概率分布之间的 KL 散度：

import numpy as npclass KLDivergence:def __init__(self, eps=1e-10):self.eps = eps  # 防止出现 log(0)def kl_divergence(self, p, q):"""计算两个离散概率分布 P 和 Q 之间的 KL 散度。参数:p (np.array): 分布 P 的概率值。q (np.array): 分布 Q 的概率值。返回:float: P 相对于 Q 的 KL 散度。"""p = np.asarray(p, dtype=np.float)q = np.asarray(q, dtype=np.float)# 防止分母为零q = np.clip(q, self.eps, 1 - self.eps)# 计算 KL 散度kl_div = np.sum(np.where(p != 0, p * np.log(p / q), 0))return kl_div# 示例代码
if __name__ == "__main__":kld = KLDivergence()# 定义两个概率分布p = np.array([0.1, 0.4, 0.5])q = np.array([0.2, 0.3, 0.5])# 计算 KL 散度kl_div = kld.kl_divergence(p, q)print("KL Divergence:", kl_div)

nlp demo 1

在自然语言处理（NLP）中，KL 散度可以用于多种场景，比如评估文档的主题分布一致性、语料库中的词频分布比较等。这里提供一个使用 KL 散度来比较两个文档中词频分布的例子。我们将使用 scikit-learn 库来提取文档的词频，并计算它们之间的 KL 散度。

示例说明

在这个例子中，我们将使用 TF-IDF（Term Frequency-Inverse Document Frequency）来表示文档中的词频，并计算两个文档之间的 KL 散度。TF-IDF 是一种常用的文本特征表示方法，它可以衡量一个词对文档的重要程度。

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.stats import entropyclass DocumentComparator:def __init__(self):self.vectorizer = TfidfVectorizer()self.eps = 1e-10def fit_transform(self, documents):"""使用 TF-IDF 向量化器将文档转换为 TF-IDF 特征向量。参数:documents (list of str): 文档列表。返回:np.array: TF-IDF 特征矩阵。"""tfidf_matrix = self.vectorizer.fit_transform(documents)return tfidf_matrix.toarray()def calculate_kl_divergence(self, doc1_tfidf, doc2_tfidf):"""计算两个文档 TF-IDF 特征向量之间的 KL 散度。参数:doc1_tfidf (np.array): 第一个文档的 TF-IDF 特征向量。doc2_tfidf (np.array): 第二个文档的 TF-IDF 特征向量。返回:float: 两个文档之间的 KL 散度。"""# 将 TF-IDF 向量归一化为概率分布doc1_prob = doc1_tfidf / np.sum(doc1_tfidf)doc2_prob = doc2_tfidf / np.sum(doc2_tfidf)# 防止分母为零doc2_prob = np.clip(doc2_prob, self.eps, 1 - self.eps)# 计算 KL 散度kl_div = entropy(doc1_prob, doc2_prob)return kl_div# 示例代码
if __name__ == "__main__":comparator = DocumentComparator()# 定义两个文档doc1 = "Python is a widely used high-level programming language."doc2 = "Python is a popular scripting language for data science."# 将文档转换为 TF-IDF 特征向量docs = [doc1, doc2]tfidf_matrix = comparator.fit_transform(docs)# 计算两个文档之间的 KL 散度kl_div = comparator.calculate_kl_divergence(tfidf_matrix[0], tfidf_matrix[1])print("KL Divergence between documents:", kl_div)

nlp demo 2

结合 Transformer 模型（如 BERT、GPT-2、T5 或 Llama2）与 KL 散度，我们可以构建一个更复杂的系统，用于评估不同文档或句子之间的相似性。这可以通过以下几种方式实现：

• 使用预训练模型生成句子嵌入：使用 Transformer 模型来生成句子或文档级别的嵌入向量。
• 计算句子嵌入的概率分布：将句子嵌入转换为概率分布。
• 计算 KL 散度：使用 KL 散度来比较两个句子的概率分布。

这里我们使用 Hugging Face 的 Transformers 库来加载预训练的模型，并计算句子之间的 KL 散度。我们将使用 BERT 作为示例模型，但这种方法同样适用于 GPT-2、T5 或 Llama2 等其他 Transformer 模型。

import torch
from transformers import AutoTokenizer, AutoModel
from scipy.special import rel_entr
import numpy as npclass SentenceEmbeddingComparator:def __init__(self, model_name="bert-base-uncased"):"""初始化 SentenceEmbeddingComparator 类。参数:model_name (str): 预训练模型的名字，默认为 'bert-base-uncased'。"""# 设置设备为 GPU 如果可用，否则使用 CPUself.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 加载预训练的分词器和模型self.tokenizer = AutoTokenizer.from_pretrained(model_name)self.model = AutoModel.from_pretrained(model_name).to(self.device)# 设置模型为评估模式self.model.eval()def _mean_pooling(self, model_output, attention_mask):"""对模型输出执行平均池化以获取句子级别的嵌入。参数:model_output (torch.Tensor): 模型的输出。attention_mask (torch.Tensor): 注意力掩码，指示哪些位置是填充的。返回:torch.Tensor: 句子级别的嵌入。"""# 获取最后一层的隐藏状态token_embeddings = model_output.last_hidden_state# 扩展注意力掩码以匹配嵌入的维度input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()# 计算每句话的嵌入的加权和sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)# 计算每个位置的有效掩码数量sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)# 计算平均嵌入return sum_embeddings / sum_maskdef generate_sentence_embedding(self, sentence):"""生成给定句子的嵌入。参数:sentence (str): 输入的句子。返回:np.array: 句子的嵌入向量。"""# 对输入句子进行编码并添加到设备上encoded_input = self.tokenizer(sentence, padding=True, truncation=True, max_length=128, return_tensors='pt').to(self.device)# 使用模型生成输出with torch.no_grad():model_output = self.model(**encoded_input)# 使用平均池化获取句子嵌入sentence_embedding = self._mean_pooling(model_output, encoded_input['attention_mask'])# 将嵌入从张量转换为 NumPy 数组return sentence_embedding.cpu().numpy()[0]def calculate_kl_divergence(self, emb1, emb2):"""计算两个句子嵌入之间的 KL 散度。参数:emb1 (np.array): 第一个句子的嵌入。emb2 (np.array): 第二个句子的嵌入。返回:float: 两个句子之间的 KL 散度。"""# 将嵌入向量转换为概率分布# 归一化确保概率分布的总和为 1prob1 = emb1 / np.linalg.norm(emb1, ord=1)prob2 = emb2 / np.linalg.norm(emb2, ord=1)# 计算 KL 散度kl_div = np.sum(rel_entr(prob1, prob2))return kl_div# 示例代码
if __name__ == "__main__":# 创建 SentenceEmbeddingComparator 实例comparator = SentenceEmbeddingComparator("bert-base-uncased")# 定义两个句子sentence1 = "Python is a widely used high-level programming language."sentence2 = "Python is a popular scripting language for data science."# 生成句子嵌入emb1 = comparator.generate_sentence_embedding(sentence1)emb2 = comparator.generate_sentence_embedding(sentence2)# 计算两个句子之间的 KL 散度kl_div = comparator.calculate_kl_divergence(emb1, emb2)# 输出 KL 散度print("KL Divergence between sentences:", kl_div)