python 文档相似度验证
最后更新于：2022-04-02 04:33:11
## python 文档相似度验证
```python
# coding=UTF-8
import time
import os
import sys
import re
import json
import hashlib
from Db import *
import jieba
from gensim import corpora,models,similarities
reload(sys)
sys.setdefaultencoding('utf-8')
# 1. 名词与概念:
# 文档: 字符串
# 词: 一个词语
# 集(合): 集合中的每个元素都是唯一的
# 分词列表: 结巴分词库返回的词列表(非集合,而是可能会有重复的词,这点很重要!!!)
# 词袋: 可以看做是分词的集合 (不重复)
# 语料库: 一个向量, 表示了词袋中的每个词 在 某个分词列表 中出现的频率(频率为0, 即没在分词列表中出现的词不计入向量)
# 向量: [(a, b), ...] a:词, b:频率 (纯数学的概念是一组坐标值,这里是一个列表,每一项为一个元组,元组里面两个元素)
# tip: 测试语料库 用来匹配的, 语料库 用来被匹配的, 相当于 搜索词 和 搜索源数据库 (d0 ~ d7 相当于表中的记录)
# 要解决的问题: 得到 一个字符串 与 其它多条字符串 之间的相关性值
# 解决方式: 一个 分词列表 与 其它 多个分词列表 之间的相关性值(中间有计算 文档中每个词的TF-IDF值 等过程), 即最终得到与每个目标文档的相似度
# 分词列表 = jieba.cut(待分词的字符串 即文档)
# 词袋 = corpora.Dictionary(分词列表的列表)
# 语料库 = 词袋.doc2bow(分词列表)
# -----
# 2. 参考:
# 用Python进行简单的文本相似度分析_xiexf189的博客-CSDN博客_python 文本相似度
# https://blog.csdn.net/xiexf189/article/details/79092629
# 结巴分词
# https://github.com/fxsjy/jieba
# 一文看懂 TF-IDF (概念图解+4大变种+发展历史)
# https://easyai.tech/ai-definition/tf-idf/
# TF （Term Frequency）—— “单词频率”
# IDF（Inverse Document Frequency）—— “逆文档频率”
# ----
# 3. 流程总结:
# 1. 对 d0 ~ d7 文档进行分词,得到 分词列表, 再组合成 "分词列表的列表" [['', ...], ...]
# 2. 使用 "分词列表的列表" 生成 词袋, 即 词集合(每个词唯一了)
# 3. 用 词袋 依次 和 每个 分词列表 来生成一个个 语料库 ,d0语料库, ...
# 4. 将 生成的8个 语料库 组成一个 语料库列表
# 5. 对 语料库列表进行建模 tfidf模型 = model(语料库列表)
# 6. ____^_^____第一阶段到这里可以告一段落,可以先休息一下,我们一会再继续
# 7.
# 8. 对 t_doc 文档进行分词,得到 分词列表
# 9. 使用上面的 词袋 和 t_doc 的 分词列表 生成一个 t_doc语料库 (重点: 基于同一 词袋 生成的 语料库 之间才能进行相似性分析)
# 10. 获取测试文档中，每个词的TF-IDF值, t_doc 的 TF-IDF值 = tfidf模型[t_doc语料库] (一个向量,表示了每个词的 TF-IDF值)
# 11. 同理: d0 的 TF-IDF值 = tfidf模型[d0语料库]
# 12. 语料库转化对象 = tfidf模型[语料库列表] ()
# 13. ____^_^____再休息一会,消化一下上面的东西
# 14.
# 15. 回顾一下,现在我们有了: 词袋, 语料库列表[d0语料库, ...], tfidf模型 和 t_doc语料库, 每个文档 的 TF-IDF值, 语料库转化对象
# 16. 下面我们将利用这些已得到的东西, 来实现我们一开始的目标: 分析 t_doc 文档 与 每个目标文档 d0 ~ d7 之间的相似度
# 17. 得到 相似性对象 = similarities.SparseMatrixSimilarity(语料库转化对象, 词袋长度) ()
# 18. 答案 = 相似性对象[t_doc 的 TF-IDF值] 矩阵: (t_doc 与 d0 的相似度, ..., t_doc 与 d7 的相似度)
# 19. 对 numpy.ndarray 结果进行排序: [(a, b), ...] a: 第几个文档, b: 相似度
# 20. 同理, d0 与 d0 ~ d7 的相似度 = 相似性对象[d0 的 TF-IDF值]
# 21. 相似性对象[语料库转化对象] 得到 d0 与 d0 ~ d7, ..., d7 与 d0 ~ d7 的 相似度列表 [[...],...]
# 22. 完, 建议多看几遍
# ==========================================================
# 待进行分词的文档
doc0 = "我不喜欢上海"
doc1 = "上海是一个好地方"
doc2 = "北京是一个好地方"
doc3 = "上海好吃的在哪里"
doc4 = "上海好玩的在哪里"
doc5 = "上海是好地方"
doc6 = "上海路和上海人上海上海上海"
doc7 = "喜欢小吃"
# 将 d1 改成 '我喜欢上海,不喜欢吃' d0 和 d1 的相关性就达到了 0.65295446 (原来 0.011466),
# 但其实二者表达的是完全相反的意思,所以这个相似性,仅仅只是文本的词频率比较, 而没有任何的语义解析处理
# 测试文档（判断这个文档与其它文档的相关性）
# 用少文档 去匹配 多文档合成的分词库
doc_test = "我喜欢上海的小吃" # [(7, 0.70477605), (0, 0.54680777), (3, 0.17724207), (4, 0.17724207), (6, 0.030088982), (5, 0.013545224), (1, 0.010553493), (2, 0.0)]
# doc_test = "可以看做是集合" # [(5, 0.5692461), (1, 0.4435168), (2, 0.32457215), (0, 0.0), (3, 0.0), (4, 0.0), (6, 0.0), (7, 0.0)]
# doc_test = "可以看做集合" # [(0, 0.0), (1, 0.0), (2, 0.0), (3, 0.0), (4, 0.0), (5, 0.0), (6, 0.0), (7, 0.0)]
all_doc = []
all_doc.append(doc0)
all_doc.append(doc1)
all_doc.append(doc2)
all_doc.append(doc3)
all_doc.append(doc4)
all_doc.append(doc5)
all_doc.append(doc6)
all_doc.append(doc7)
# 全部分词列表的列表
all_doc_list = []
for doc in all_doc:
# 对每一个文档进行分词
# 默认使用了,精确分词模式
# 精确模式: 试图将句子最精确地切开，适合文本分析
# 只是将词切开,并不做词集合,这点很重要
doc_list = [word for word in jieba.cut(doc)]
all_doc_list.append(doc_list)
print all_doc_list
# exit()
# 制作语料库
# 使用全部分词列表的列表 制作词袋，每个词都是唯一的
dictionary = corpora.Dictionary(all_doc_list)
for i,item in dictionary.items():
print i, item
# exit()
# print dictionary.keys()
print dictionary.token2id
# 使用 上一步生成的词袋 和 全部分词列表的列表 制作语料库列表（唯一的词袋 再与 文档的分词列表 生成语料库，即一组向量 ）
# 语料库是一个向量，向量中的每个元素是一个二元组（编号、频次数），对应分词后的文档中的每一个词
# 语料库列表
corpus = [dictionary.doc2bow(doc) for doc in all_doc_list]
# 向量列表
print corpus
# exit()
# tip: 将这些向量列表合并（词频累加），就能得出 之前的 分词文档列表集 中的词频
# 同理，现在也对 测试文档进行处理
# 现在对测试文档也进行分词
doc_test_list = [word for word in jieba.cut(doc_test)]
print doc_test_list
# 用 上面生成的词袋 和 测试文档分词列表 制作一个语料库
# 这里的关键是，制作语料库 使用的是 上面的词袋（搜索词集），这为后面计算相关性埋下伏笔
doc_test_vec = dictionary.doc2bow(doc_test_list)
print doc_test_vec
# doc_test_vec = dictionary.doc2bow(['上海1', '上海1', '湖北'])
# print doc_test_vec
# 相当于现在得到了 测试的分词列表 与 搜索词集 的 向量，即词频
# 但 也只是知道了 词频关系，还是无法得知 测试的分词列表 究竟与 哪个 文档 相关性最高
# exit()
# 下面开始计算相关性
# 使用TF-IDF模型对语料库建模 (使用语料库列表进行建模)
tfidf = models.TfidfModel(corpus)
# 语料库模型 = models.TfidfModel(语料库列表)
# TfidfModel(num_docs=8, num_nnz=34)
print tfidf, type(tfidf)
# 上面埋下的伏笔开始显现作用了：只有使用了相同的词袋生成的语料库之间才能够计算相似性
# 获取测试文档中，每个词的TF-IDF值 (使用测试语料库)
# 值是一个向量: [(a, b), ...] a:词, b: TF-IDF值
doc_test_tfidf = tfidf[doc_test_vec]
print doc_test_tfidf
# 第一个文档中,每个词的TF-IDF值 (使用第一个文档的语料库)
print tfidf[corpus[0]]
#
print tfidf[corpus]
# 对每个目标文档，分析测试文档的相似度
index = similarities.SparseMatrixSimilarity(tfidf[corpus], num_features=len(dictionary.keys()))
#
print index
# 测试语料库 与 每个 语料库 的相似度
sim = index[doc_test_tfidf]
#
print 'sim', sim, type(sim)
# 第一个语料库 与 每个 语料库的相似度
print index[tfidf[corpus[0]]]
# 全部语料库 与 语料库列表本身 的相似度列表
# 相当于 d0 与 d0 ~ d7, ..., d7 与 d0 ~ d7 的 相似度列表 [[...],...]
print index[tfidf[corpus]]
# 根据相似度排序
print sorted(enumerate(sim), key=lambda item: -item[1])
```
last update: 2020-11-20 21:32:02
';