基于规则嵌入的论文比对系统（5）-数据处理2

最新推荐文章于 2022-08-28 09:07:00 发布
最新推荐文章于 2022-08-28 09:07:00 发布
阅读量386 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43665502/article/details/106732685
版权

数据处理-2

环境

python3 keras=2.0.6

思路

这里主要是对后面将要的构建的模型的输入进行处理。

我们的系统的核心功能是对于输入的论文集合分别在5个子空间（0.研究背景 1.研究问题 2.贡献 3.方法 4.实验）上输出相似的论文对，从而实现更细粒度的论文之间的比较。

所以对于 模型输入 ，应该是对于一个论文对的序列化表示，这里我将其设计成 语义 和 规则 的拼接，关于这两部分的具体介绍后续博客会详细说明。

还有一个问题就是，我们的系统从本质上来说应该是一个有监督的 分类 问题,但是我们当前所拥有的数据集是没有 label 的数据的，也就是我们不知道在某个子空间上，输入的这个论文对到底是属于正样本对，还是负样本对，所以需要我们人工的在5个子空间上进行训练集的构建。

该博客主要延续上一篇 训练集的构建

构建训练集

在上一篇 基于规则嵌入的论文比对系统（4） 中,已经将 sentence_textcnn.json 的数据进行了初步处理，得到了在5个子空间（0.研究背景 1.研究问题 2.贡献 3.方法 4.实验）上经过sentence融合的字典（key是paper_id,item是融合之后的sentence），接下来将在此基础上进行处理。

注意：每篇论文并不是每个子空间都有，每个子空间也不一定只有一个句子。

计算文本相似度的类

算法说明

在计算文本相似度时，我们使用TF-IDF模型。

tf即词频term frequency,表示词w在文档d中出现次数count(w,d)和文档d中总词数size(d)的比值：

在这里插入图片描述
idf即逆文档频率inverse document frequency，表示文档总数n和词w所出现文件数docs(w，d)比值的对数：
在这里插入图片描述
根据
在这里插入图片描述

作为权重来将每一篇文档表示为一个权重向量，并根据余弦相似度作为文档之间的相似度。

注意：这里就是将每篇论文每个子空间上的sentence都作为一个doc.

tf-idf部分参考资料

tf-idf模型参考对象

代码

class DocumentSimilar(object):
    def __init__(self, documents):
        self.documents = documents
        self.dictionary = None
        self.tfidf = None
        self.similar_matrix = None
        self.calculate_similar_matrix()
    @staticmethod
    def split_word(document):
        """
        分词，去除停用词
        """
        text=document.split(" ")
        return text
    def calculate_similar_matrix(self):
        """
        计算相似度矩阵及一些必要数据
        """ 
        words = [self.split_word(document) for document in self.documents]
        self.dictionary = corpora.Dictionary(words)
        corpus = [self.dictionary.doc2bow(word) for word in words]
        self.tfidf = models.TfidfModel(corpus)
        corpus_tfidf = self.tfidf[corpus]
        self.similar_matrix = similarities.Similarity("",corpus_tfidf,len(self.dictionary))
     def get_similar(self, document):
        """
        计算要比较的文档与语料库中每篇文档的相似度
        """
        words = self.split_word(document)
        corpus = self.dictionary.doc2bow(words)
        corpus_tfidf = self.tfidf[corpus]
        return self.similar_matrix[corpus_tfidf]

计算列表中第二大的数

def SecMax(list):
    list.sort()
    count=list.count(list[len(list) - 1] )
    c = 0
    while c < count:
        list.pop()
        c+=1
    return list[len(list) - 1]

根据上面的文本相似度的类，在每个子空间上计算出论文对之间的相似度，为每篇论文找出和它最相似的论文

代码

#子空间0
documents0=[]
index_list0=[]
for key,value in SubSpace0_dict.items():
    index_list0.append(key)
    documents0.append(value)
SubSpace0_train_pairs=[]
SubSpace0_train_pairs_=[]
doc_similar0=DocumentSimilar(documents0)
for key,value in SubSpace0_dict.items():
    a=key
    temp=list(doc_similar0.get_similar(value))
    temp_=temp.copy()
    Second_Num=SecMax(temp_)
    min_num=min(temp)
    Second_Maxnum_Index=temp.index(Second_Num)
    min_num_index=temp.index(min_num)
    c=index_list0[min_num_index]
    b=index_list0[Second_Maxnum_Index]
    SubSpace0_train_pairs.append([a,b,Second_Num])
    SubSpace0_train_pairs_.append([a,c,min_num])

#子空间1
documents1=[]
index_list1=[]
for key,value in SubSpace1_dict.items():
    index_list1.append(key)
    documents1.append(value)
SubSpace1_train_pairs=[]
SubSpace1_train_pairs_=[]
doc_similar1=DocumentSimilar(documents1)
for key,value in SubSpace1_dict.items():
    a=key
    temp=list(doc_similar1.get_similar(value))
    temp_=temp.copy()
    Second_Num=SecMax(temp_)
    min_num=min(temp)
    Second_Maxnum_Index=temp.index(Second_Num)
    min_num_index=temp.index(min_num)
    c=index_list1[min_num_index]
    b=index_list1[Second_Maxnum_Index]
    SubSpace1_train_pairs.append([a,b,Second_Num])
    SubSpace1_train_pairs_.append([a,c,min_num])

#子空间2
documents2=[]
index_list2=[]
for key,value in SubSpace2_dict.items():
    index_list2.append(key)
    documents2.append(value)

SubSpace2_train_pairs=[]
SubSpace2_train_pairs_=[]
doc_similar2=DocumentSimilar(documents2)
for key,value in SubSpace2_dict.items():
    a=key
    temp=list(doc_similar2.get_similar(value))
    temp_=temp.copy()
    Second_Num=SecMax(temp_)
    min_num=min(temp)
    Second_Maxnum_Index=temp.index(Second_Num)
    min_num_index=temp.index(min_num)
    c=index_list2[min_num_index]
    b=index_list2[Second_Maxnum_Index]
    SubSpace2_train_pairs.append([a,b,Second_Num])
    SubSpace2_train_pairs_.append([a,c,min_num])

#子空间3
documents3=[]
index_list3=[]
for key,value in SubSpace3_dict.items():
    index_list3.append(key)
    documents3.append(value)
SubSpace3_train_pairs=[]
SubSpace3_train_pairs_=[]
doc_similar3=DocumentSimilar(documents3)

for key,value in SubSpace3_dict.items():
    a=key
    temp=list(doc_similar3.get_similar(value))
    temp_=temp.copy()
    Second_Num=SecMax(temp_)
    min_num=min(temp)   
    Second_Maxnum_Index=temp.index(Second_Num)
    min_num_index=temp.index(min_num)
    c=index_list3[min_num_index]   
    b=index_list3[Second_Maxnum_Index]
    SubSpace3_train_pairs.append([a,b,Second_Num])
    SubSpace3_train_pairs_.append([a,c,min_num])

#子空间4
documents4=[]
index_list4=[]
for key,value in SubSpace4_dict.items():
    index_list4.append(key)
    documents4.append(value)
SubSpace4_train_pairs=[]
SubSpace4_train_pairs_=[]
doc_similar4=DocumentSimilar(documents4)

for key,value in SubSpace4_dict.items():
    a=key
    temp=list(doc_similar4.get_similar(value))
    temp_=temp.copy()
    Second_Num=SecMax(temp_)
    min_num=min(temp)   
    Second_Maxnum_Index=temp.index(Second_Num)
    min_num_index=temp.index(min_num)  
    c=index_list4[min_num_index]   
    b=index_list4[Second_Maxnum_Index]
    SubSpace4_train_pairs.append([a,b,Second_Num])
    SubSpace4_train_pairs_.append([a,c,min_num])

运行结果可视化展示
前两列是两篇论文的paper_id，最后一列是在某个子空间上的文本相似度

  • 子空间0（正样本）
    在这里插入图片描述
  • 子空间0（负样本）
    在这里插入图片描述
  • 子空间1（正样本）
    在这里插入图片描述
  • 子空间1（负样本）
    在这里插入图片描述
  • 子空间2（正样本）
    在这里插入图片描述
  • 子空间2（负样本）
    在这里插入图片描述
  • 子空间3（正样本）
    在这里插入图片描述
  • 子空间3（负样本）
    在这里插入图片描述
  • 子空间4（正样本）
    在这里插入图片描述
  • 子空间4（负样本）
    在这里插入图片描述

运行上面的代码时间很长，所以可以把得到的列表存起来（例如子空间0的相关数据存储）

SubSpace0_train_pairs=np.array(SubSpace0_train_pairs)
np.save('data/SubSpace0_train_pairs+.npy',SubSpace0_train_pairs)
SubSpace0_train_pairs=np.load('data/SubSpace0_train_pairs+.npy')
SubSpace0_train_pairs=SubSpace0_train_pairs.tolist()

在每个子空间挑出100个作为正样本对，100个作为负样本对

挑选方案：正样本，选择相似度最高的100对；负样本，选择相似度最低的100对

代码

#子空间0
#100个正样本对
list0=[each[-1] for each in SubSpace0_train_pairs]
array0=np.array(list0)
Max100_0=list(array0.argsort()[-100:][::-1])
Max100_0_pos=[]
for each in Max100_0:
    temp=[]
    temp_li=SubSpace0_train_pairs[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Max100_0_pos.append(temp)
#100个负样本对
list0_=[each[-1] for each in SubSpace0_train_pairs_]
array0_=np.array(list0_)
Min100_0_=list(array0_.argsort()[:100][::])
Min100_0_neg=[]
for each in Min100_0_:
    temp=[]
    temp_li=SubSpace0_train_pairs_[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_0_neg.append(temp)


#子空间1
#100个正样本对
list1=[each[-1] for each in SubSpace1_train_pairs]
array1=np.array(list1)
Max100_1=list(array1.argsort()[-100:][::-1])
Max100_1_pos=[]
for each in Max100_1:
    temp=[]
    temp_li=SubSpace1_train_pairs[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Max100_1_pos.append(temp)
#100个负样本对
list1_=[each[-1] for each in SubSpace1_train_pairs_]
array1_=np.array(list1_)
Min100_1_=list(array1_.argsort()[:100][::])
Min100_1_neg=[]
for each in Min100_1_:
    temp=[]
    temp_li=SubSpace1_train_pairs_[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_1_neg.append(temp)

#子空间2
#100个正样本对
list2=[each[-1] for each in SubSpace2_train_pairs]
array2=np.array(list2)
Min100_2=list(array2.argsort()[-100:][::-1])
Min100_2_pos=[]
for each in Min100_2:
    temp=[]
    temp_li=SubSpace2_train_pairs[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_2_pos.append(temp)
#100个负样本对
list2_=[each[-1] for each in SubSpace2_train_pairs_]
array2_=np.array(list2_)
Min100_2_=list(array2_.argsort()[:100][::])
Min100_2_neg=[]
for each in Min100_2_:
    temp=[]
    temp_li=SubSpace2_train_pairs_[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_2_neg.append(temp)

#子空间3
#100个正样本对
list3=[each[-1] for each in SubSpace3_train_pairs]
array3=np.array(list3)
Max100_3=list(array3.argsort()[-100:][::-1])
Max100_3_pos=[]
for each in Max100_3:
    temp=[]
    temp_li=SubSpace3_train_pairs[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Max100_3_pos.append(temp)
#100个负样本对
list3_=[each[-1] for each in SubSpace3_train_pairs_]
array3_=np.array(list3_)
Min100_3_=list(array3_.argsort()[:100][::])
Min100_3_neg=[]
for each in Min100_3_:
    temp=[]
    temp_li=SubSpace3_train_pairs_[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_3_neg.append(temp)

#子空间4
#100个正样本对
list4=[each[-1] for each in SubSpace4_train_pairs]
array4=np.array(list4)
Max100_4=list(array4.argsort()[-100:][::-1])
Max100_4_pos=[]
for each in Max100_4:
    temp=[]
    temp_li=SubSpace4_train_pairs[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Max100_4_pos.append(temp)
#100个负样本对
list4_=[each[-1] for each in SubSpace4_train_pairs_]
array4_=np.array(list4_)
Min100_4_=list(array4_.argsort()[:100][::])
Min100_4_neg=[]
for each in Min100_4_:
    temp=[]
    temp_li=SubSpace4_train_pairs_[int(each)]
    temp.append(int(temp_li[0]))
    temp.append(int(temp_li[1]))
    Min100_4_neg.append(temp)

运行结果可视化展示

  • 子空间0（100个正样本对）
    在这里插入图片描述
  • 子空间0（100个负样本对）
    在这里插入图片描述
  • 子空间1（100个正样本对）
    在这里插入图片描述
  • 子空间1（100个负样本对）
    在这里插入图片描述
  • 子空间2（100个正样本对）
    在这里插入图片描述
  • 子空间2（100个负样本对）
    在这里插入图片描述
  • 子空间3（100个正样本对）
    在这里插入图片描述
  • 子空间3（100个负样本对）
    在这里插入图片描述
  • 子空间4（100个正样本对）
    在这里插入图片描述
  • 子空间4（100个负样本对）
    在这里插入图片描述

总结

至此，已经得到了在5个子空间上的训练样本。整个数据处理过程中最经常报的错误就是out of index的错误，但是基本上根据错误提示信息都能很快找到报错的位置，总体来说比较顺利。

下一步就是对于输入文本进行序列化的处理，规则的嵌入，以及模型的构建。

qq_43665502
关注
论文研究-基于指纹识别技术的考勤管理系统的设计与实现 .pdf
08-18
综上所述，基于指纹识别技术的考勤管理系统通过其高精确度的生物识别技术和自动化处理功能，极大提高了考勤管理的效率和准确性，已经成为现代化企业、政府机关、教育机构等组织单位广泛应用的一种高效管理工具。
数据挖掘之分类——基于规则的分类器
weixin_30293135的博客
05-04 956
算法简介 　　基于规则的分类器是使用一组"if...then..."规则来对记录进行分类的技术。 　　模型的规则用析取范式 R =(r1 ∨ r2 ∨ ••• ∨ rk)表示，其中R称作规则集，ri 是分类规则或析取项。 　　每一个分类规则可以表示为如下形式： ri:(条件i)→yi 规则左边成为规则前件或前提。它是属性测试的合取： 条件i=(A1 op v1)∧(A1 op...
什么是分子优化（Molecule Optimization）以及相关论文
MOL
08-28 2006
什么是分子优化（Molecule Optimization）以及相关论文
Python编程：使用gensim对中文文本进行相似度计算
彭世瑜的博客
02-25 6499
gensim文档： https://radimrehurek.com/gensim/tutorial.html 安装 pip install gensim 代码示例 # -*- coding: utf-8 -*- import logging import jieba from gensim import corpora, models, similarities logging.bas...
GPFL(二)-Execute rule learning only
woshiwu6666的博客
08-18 439
以第一条数据为例relationId 是735，headId 是407，type是PUBLISHES,tailid是266。使用无限 BlockingQueue 设计生产者 - 消费者模型时最重要的是。1841条数据，其中有440条数据与Publishes相关。以第一个target，publishes为例。指定文件夹路径，创建相应的文件。将相关信息保存到Pairs当中。...
基于规则嵌入的论文比对系统（17）-总结
qq_43665502的博客
06-29 158
总结
论文研究-基于BIOS和USB盘实现对PC机的安全访问.pdf
07-22
文章描述了一个具体的操作流程，包括读取USB盘中的数据、对用户输入进行MD5哈希算法处理、与存储在USB盘中的正确哈希值进行比对、根据比对结果决定是否继续启动操作系统等步骤。这整个过程涉及到了对硬件层面的编程...
基于规则嵌入的论文比对系统(四）
lw03060402的博客
06-18 199
数据集爬取及处理子空间标签数据处理与展示数据预处理可视化实现及效果展示关系图可视化：数据预处理可视化不同年份上论文集的个数（柱状图）不同年份上论文集的平均引用量、被引用量（柱状图）不同年份上论文的引用量、被引用量（盒须图） 子空间标签数据处理与展示 数据预处理 思路：首先根据sentence_TextCNN.json构建一个list,list的元素类型是字典，每个元素对应一篇论文。字典格式： 其中，paper_id是论文的id，0-4对应五个子空间，分别是研究背景、研究问题、贡献、方法、实验。0-4对应的
两篇论文中的 ConvLSTM 对比
GerHard 的博客
03-05 8934
【这篇重点在分析一下改变了的网络模型，其他的写的并不全面】 1、《Deep Learning Approach for Sentiment Analysis of Short Texts》 learning long-term dependencies with gradient descent is difcult in neural network language model bec...
比较两篇文章的相似性方法
Jiakunboy的专栏
05-02 8282
对于这个题目，开始毫无头绪，后来经过查阅资料现在讲方法总结如下：     1、利用余弦定理      我们知道向量a,b之间的夹角可用余弦定理求得：                  如果夹角的余弦值越小，那么夹角也越大。如果2个向量相等，那么其值为1。利用此我们可以用来比较文章的相似性。     首先使用一个向量来描述一篇文章，对于一篇文章中的实词，我们可以计算出它们的单文本词汇频率/逆文本频率
基于规则嵌入的论文比对系统——创新实训记录11
WX1204的博客
06-26 204
6-26 两个规则（关键词）的修改-语义上 创新实训记录11思路具体实现 之前是直接计算两个关键词集合的杰卡德相似度，没有考虑关键词的语义信息，导致overlap的数据非常少，而不同的单词可能表达的语义是相近的，所以需要对这个规则进行修改。 思路 思路：首先进行word embedding，将单词转换为向量。然后定义求两组关键词相似度的函数。假设我们有两个关键词集合，分别是{a1,a2,…,an}，{b1,b2,…,bm}（假设n>m），将a1与b1,…,bm分别求余弦相似度，取max，同理，a2,…
the meaning of training pairs
weixin_46021869的博客
09-10 183
Each training pair consists of input data together with the corresponding target . The goal of the algorithm is to learn a mapping from the input data to the target value so that the target ⁎ for some unseen data ⁎ can be predicted.
美修大数据：2022母婴洗护品类洞察报告(2).pdf
最新发布
11-03
美修大数据：2022母婴洗护品类洞察报告(2).pdf
VB程序实例-图片剪切.zip
11-03
VB程序实例-图片剪切.zip
JSP技术实现论文查重系统设计与源码解析
在本系统中，MySQL用于存储系统数据，包括用户信息、管理员信息、系统样本和学生论文内容。为了与JSP和Java技术集成，开发者需要配置JDBC（Java Database Connectivity）驱动，以实现Java应用程序与MySQL数据库之间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值