智能问答系统python实现_python问答程序,python自动问答代码-Python文档类资源-CSDN文库

版权申诉

python

5星 · 超过95%的资源 2.8k 浏览量 2021-12-04 15:42:15 上传评论 12 收藏 42.11MB ZIP 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

共20个文件

py：11个

pyc：4个

docx：3个

资源推荐

资源详情

资源评论

收起资源包目录

970924.zip （20个子文件）

kbqa

整片论文说明以及实现说明.docx 13KB

kbqa.docx 23KB

实现一版说明.docx 26KB

me_train.json 289.65MB

kbqa

read_data.py 3KB

user_dict.py 414B

caculate_pro.py 14KB

zhuan.py 2KB

__init__.py 0B

__pycache__

__init__.cpython-35.pyc 130B

caculate_pro.cpython-35.pyc 7KB

entity_recognize.cpython-35.pyc 11KB

connectSQLServer.cpython-35.pyc 2KB

entity_recognize.py 19KB

calculate_EM.py 17KB

qa_main.py 6KB

chen.py 5KB

connectSQLServer.py 1KB

entity_recognize_mongdb.py 6KB

p565-cui.pdf 720KB

KBQA: Learning Question Answering over QA Corpora

and Knowledge Bases

Wanyun Cui

Yanghua Xiao

Haixun Wang

‡

Yangqiu Song

Seung-won Hwang

]

Wei Wang

Shanghai Key Laboratory of Data Science, School of Computer Science, Fudan University

‡

Facebook

HKUST

]

Yonsei University

wanyuncui1@gmail.com, shawyh@fudan.edu.cn, haixun@gmail.com, yqsong@cse.ust.hk,

seungwonh@yonsei.ac.kr, weiwang1@fudan.edu.cn

ABSTRACT

Question answering (QA) has become a popular way for humans to

access billion-scale knowledge bases. Unlike web search, QA over

a knowledge base gives out accurate and concise results, provid-

ed that natural language questions can be understood and mapped

precisely to structured queries over the knowledge base. The chal-

lenge, however, is that a human can ask one question in many dif-

ferent ways. Previous approaches have natural limits due to their

representations: rule based approaches only understand a small set

of “canned” questions, while keyword based or synonym based ap-

proaches cannot fully understand the questions. In this paper, we

design a new kind of question representation: templates, over a

billion scale knowledge base and a million scale QA corpora. For

example, for questions about a city’s population, we learn tem-

plates such as What’s the population of $city?, How

many people are there in $city?. We learned 27 mil-

lion templates for 2782 intents. Based on these templates, our QA

system KBQA effectively supports binary factoid questions, as well

as complex questions which are composed of a series of binary fac-

toid questions. Furthermore, we expand predicates in RDF knowl-

edge base, which boosts the coverage of knowledge base by 57

times. Our QA system beats all other state-of-art works on both

effectiveness and efﬁciency over QALD benchmarks.

1. INTRODUCTION

Question Answering (QA) has drawn a lot of research inter-

ests. A QA system is designed to answer a particular type of

questions [5]. One of the most important types of question-

s is the factoid question (FQ), which asks about objective fact-

s of an entity. A particular type of FQ, known as the bi-

nary factoid question (BFQ) [1], asks about a property of an

entity. For example, how many people are there in

Honolulu? If we can answer BFQs, then we will be able

to answer other types of questions, such as 1) ranking question-

s: which city has the 3rd largest population?;

2) comparison questions: which city has more people,

Honolulu or New Jersey?; 3) listing questions: list

This work is licensed under the Creative Commons Attribution-

NonCommercial-NoDerivatives 4.0 International License. To view a copy

of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/. For

any use beyond those covered by this license, obtain permission by emailing

info@vldb.org.

Proceedings of the VLDB Endowment, Vol. 10, No. 5

cities ordered by population etc. In addition to BFQ

and its variants, we can answer a complex factoid question such

as when was Barack Obama’s wife born? This can

be answered by combining the answers of two BFQs: who’s

Barack Obama’s wife? (Michelle Obama) and when was

Michelle Obama born? (1964). We deﬁne a complex fac-

toid question as a question that can be decomposed into a series

of BFQs. In this paper, we focus on BFQs and complex factoid

questions.

QA over a knowledge base has a long history. In recent years,

large scale knowledge bases become available, including Google’s

Knowledge Graph, Freebase [3], YAGO2 [16], etc., greatly in-

crease the importance and the commercial value of a QA system.

Most of such knowledge bases adopt RDF as data format, and they

contain millions or billions of SPO triples (S, P , and O denote

subject, predicate, and object respectively).

Barack Obama

1992

Michelle

Obama

marriage

name

person

name

1961

dob

1964

dob

Honolulu

390K

Event

CityPolitician

Person

category

date

category

Person

category

name

population

category

pob

Figure 1: A toy RDF knowledge base (here, “dob” and “pob” s-

tand for “date of birth” and “place of birth” respectively). Note

that the “spouse of” intent is represented by multiple edges:

name - marriage - person - name.

1.1 Challenges

Given a question against a knowledge base, we face two chal-

lenges: in which representation we understand the questions (repre-

sentation designment), and how to map the representations to struc-

tured queries against the knowledge base (semantic matching)?

• Representation Designment: Questions describe thousands of

intents, and one intent has thousands of question templates. For

example, both

 and

 in Table 1 ask about population of Hon-

olulu, although they are expressed in quite different ways. The

QA system needs different representations for different ques-

tions. Such representations must be able to (1) identify ques-

tions with the same semantics; (2) distinguish different ques-

tion intents. In the QA corpora we use, we ﬁnd 27M question

templates over 2782 question intents. So it’s a big challenge to

design representations to handle this.

565

• Semantic Matching: After ﬁguring out the representation of

a question, we need to map the representation to a structured

query. For BFQ, the structured query mainly depends on the

predicate in the knowledge base. Due to the gap between pred-

icates and question representations, it is non-trivial to ﬁnd such

mapping. For example, in Table 1, we need to know

 has the

same semantics with predicate population. Moreover, in RDF

graph, many binary relations do not correspond to a single edge

but a complex structure: in Figure 1, “spouse of” is expressed

by a path marriage → person → name. For the knowledge

base we use, over 98% intents we found correspond to complex

structures.

Table 1: Questions in Natural Language and Related Predicates in a

Knowledge Base

Question in Natural language Predicate in KB

 How many people are there in Honolulu? population

 What is the population of Honolulu? population

 What is the total number of people in Honolulu? population

 When was Barack Obama born? dob

 Who is the wife of Barack Obama? marriage→person→name

 When was Barack Obama’s wife born? marriage→person→name

dob

Thus, the key problem is to build a mapping between natural

language questions and knowledge base predicates through proper

question representations.

1.2 Previous Works

According to how previous knowledge based QA systems repre-

sent questions, we roughly classify them into three categories: rule

based, keyword based, and synonym based.

1. Rule based [23]. Rule based approaches map questions to pred-

icates by using manually constructed rules. This leads to high

precision but low recall (low coverage of the variety of question-

s), since manually creating rules for a large number of questions

is infeasible.

2. Keyword based [29]. Keyword based methods use keywords

in the question and map them to predicates by keyword match-

ing. They may answer simple questions such as

 in Table 1 by

identifying population in the question and mapping it to predi-

cate population in the knowledge base. But in general, using

keywords can hardly ﬁnd such mappings, since one predicate

representation in the knowledge base cannot match diverse rep-

resentations in natural language. For example, we cannot ﬁnd

population from

 or

.

3. Synonym based [28, 33, 38, 37]. Synonym based methods ex-

tend keyword based methods by taking synonyms of the predi-

cates into consideration. They ﬁrst generate synonyms for each

predicate, and then ﬁnd mappings between questions and these

synonyms. DEANNA [33] is a typical synonym based QA sys-

tem. The main idea is reducing QA into the evaluation of se-

mantic similarity between predicate and candidate synonyms

(words/phrases in the question). It uses Wikipedia to com-

pute the semantic similarity. For example, question

 in Ta-

ble 1 can be answered by knowing that number of people

in the question is a synonym of predicate population. Obvi-

ously, their semantic similarity can be evaluated by Wikipedi-

a. gAnswer [38, 37] further improved the precision by learn-

ing synonyms for more complex sub-structures. However, al-

l these approaches cannot answer

 in Table 1, as none of

how many, people, are there has obvious relation with

population. How many people is ambiguous in different

context. In how many people live in Honolulu?, it

refers to population. In how many people visit New

York each year?, it refers to number of passengers.

In general, these works cannot solve the above challenges. For

rule based approaches, it takes unaffordable human labeling effort.

For keyword based or synonym based approaches, one word or one

phrase cannot represent the question’s semantic intent complete-

ly. We need to understand the question as a whole. And it’s even

tremendously more difﬁcult for previous approaches if the question

is a complex question or maps to a complex structure in a knowl-

edge base (e.g.

 or

).

1.3 Overview of Our Approach

Figure 2: Our Approach

To answer a question, we must ﬁrst represent the question. By

representing a question, we mean transforming the question from

natural language to an internal representation that captures the se-

mantics and intent of the question. Then, for each internal repre-

sentation, we learn how to map it to an RDF query against a knowl-

edge base. Thus, the core of our work is the internal representation

which we denote as templates.

Representing questions by templates The failure of synonym

based approach in

 inspires us to understand a question by tem-

plates. As an example, How many people are there in

$city? is the template for

. No matter $city refers to Honolu-

lu or other cities, the template always asks about population of the

question.

Then, the task of representing a question is to map the question

to an existing template. To do this, we replace the entity in the

question by its concepts. For instance, Honolulu will be replaced

by $city as shown in Figure 2. This process is not trivial, and it

is achieved through a mechanism known as conceptualization [25,

17], which automatically performs disambiguation on the input

(so that the term apple in what is the headquarter of

apple will be conceptualized to $company instead of $fruit).

The conceptualization mechanism itself is based on a large seman-

tic network (Probase [32]) that consists of millions of concepts, so

that we have enough granularity to represent all kinds of questions.

The template idea also works for complex questions. Using

templates, we simply decompose the complex question into a series

of question, each of which corresponds to one predicate. Consid-

er question

 in Table 1. We decompose

 into Barack

Obama’s wife and when was Michelle Obama

born?, which correspond to marriage → person → name and

dob respectively. Since the ﬁrst question is nested within the sec-

ond one, we know dob modiﬁes marriage → person → name,

and marriage → person → name modiﬁes Barack Obama.

Mapping templates to predicates We learn templates and their

mappings to knowledge base predicates from Yahoo! Answers.

This problem is quite similar to the semantic parsing [6, 7]. Most

semantic parsing approaches are synonym based. To model the cor-

relation between phrases and predicates, SEMPRE [2] uses a bipar-

tite graph, and SPF [18] uses a probabilistic combinatory categori-

al grammar (CCG) [8]. They still have the drawbacks of synonym

based approaches. The mapping from templates to predicates is

n : 1, that is, each predicate in the knowledge base corresponds to

multiple templates. For our work, we learned a total of 27, 126, 355

566

different templates for 2782 predicates. The large amount guaran-

tees the wide coverage of template-based QA.

The procedure of learning the predicate of a template is as fol-

lows. First, for each QA pair in Yahoo! Answer, we extract the

entity in question and the corresponding value. Then, we ﬁnd the

predicate from the knowledge base by looking up the direct predi-

cate connecting the entity and the value. Our basic idea is, if most

instances of a template share the same predicate, we map the tem-

plate to this predicate. For example, suppose questions derived

by template how many people are there in $city? al-

ways map to the predicate population, no matter what speciﬁc

$city it is. We can conclude that for certain probability the tem-

plate maps to population. Learning templates that map to a com-

plex knowledge base structure employs a similar process. The only

difference is that we ﬁnd “expanded predicates” that correspond to

a path consisting of multiple edges which lead from an entity to a

certain value (e.g., marriage → person → name).

1.4 Paper Organization

The rest of the paper is organized as follows. In Sec 2, we give an

overview of KBQA. The major contribution of this paper is learn-

ing templates from QA corpora. All technique parts are close-

ly related to it. Sec 3 shows the online question answering with

templates. Sec 4 elaborates the predicates inference for templates,

which is the key step to use templates. Sec 5 extends our solution to

answer a complex question. Sec 6 extends the ability of templates

to infer complex predicates. We present experimental studies in

Sec 7, discuss more related works in Sec 8, and conclude in Sec 9.

2. SYSTEM OVERVIEW

In this section, we introduce some background knowledge and

give an overview of KBQA. In Table 2, we list the notations used

in this paper.

Table 2: Notations

Notation Description Notation Description

q question s subject

a answer p predicate

QA QA corpus o object

e entity K knowledge base

v value c category

t template p

expanded predicate

V (e, p) {v|(e, p, v) ∈ K} s

⊂ s

is a substring of s

t(q, e, c) template of q by θ

(s)

estimation of θ

conceptualizing e to c at iteration s

Binary factoid QA We focus on binary factoid questions

(BFQs), that is, questions asking about a speciﬁc property of an

entity. For example, all questions except

 in Table 1 are BFQs.

RDF knowledge base Given a question, we ﬁnd its answer in

an RDF knowledge base. An RDF knowledge base K is a set of

triples in the form of (s, p, o), where s, p, and o denote subjec-

t, predicate, and object respectively. Figure 1 shows a toy RDF

knowledge base via an edge-labeled directed graph. Each (s, p, o)

is represented by a directed edge from s to o labeled with predicate

p. For example, the edge from a to 1961 with label dob represents

an RDF triple (a, dob, 1961), which represents the knowledge of

Barack Obama’s birthday.

Table 3: Sample QA Pairs from a QA Corpus

Id Question Answer

, a

) When was Barack Obama

born?

The politician was born in

1961.

, a

) When was Barack Obama

born?

He was born in 1961.

, a

) How many people are

there in Honolulu?

It’s 390K.

QA corpora We learn question templates from Yahoo! Answer,

which consists of 41 million QA pairs. The QA corpora is denoted

by QA = {(q

, a

), (q

, a

), ..., (q

, a

)}, where q

is a ques-

tion and a

is the reply to q

. Each reply a

consists of several

sentences, and the exact factoid answer is contained in the reply.

Table 3 shows a sample from a QA corpus.

Templates. We derive a template t from a question q by replacing

each entity e with one of e’s categories c. We denote this template

as t = t(q, e, c). A question may contain multiple entities, and

an entity may belong to multiple categories. We obtain concept

distribution of e through context-aware conceptualization [32]. For

example, question q

in Table 3 contains entity a in Figure 1. Since

a belongs to two categories: $Person, $Politician, we can derive

two templates from the question: When was $Person born?

and When was $Politician born?.

Figure 3: System Overview

System Architecture. Figure 3 shows the pipeline of our QA sys-

tem, which consists of two major procedures:

• Online procedure: When a question comes in, we ﬁrst parse

and decompose it into a series of binary factoid questions. The

decomposition process is described in Sec 5. For each binary

factoid question, we use a probabilistic inference approach to

ﬁnd its value, shown in Sec 3. The inference is based on the

predicate distribution of given templates, i.e. P (p|t). Such dis-

tribution is learned ofﬂine.

• Ofﬂine procedure: The goal of ofﬂine procedure is to learn the

mapping from templates to predicates. This is represented by

P (p|t), which is estimated in Sec 4. And we expand predicates

in the knowledge base in Sec 6, so that we can learn more com-

plex predicate forms (e.g., marriage → person → name in

Figure 1).

3. OUR APPROACH: KBQA

In this section, we ﬁrst formalize our problem in a probabilistic

framework in Sec 3.1. We present the details for most probability

estimations in Sec 3.2, leaving only the estimation of P(p|t) in

Sec 4. We elaborate the online procedure in Sec 3.3.

3.1 Problem Model

KBQA learns question answering by using a QA corpus and a

knowledge base. Due to issues such as uncertainty (e.g. some ques-

tions’ intents are vague), incompleteness (e.g. the knowledge base

is almost always incomplete), and noise (e.g. answers in the QA

567

corpus may be wrong), we create a probabilistic model for QA over

a knowledge base below. We highlight the uncertainty from the

question’s intent to the knowledge base’s predicates [18]. For ex-

ample, the question “where was Barack Obama from” is related to

at least two predicates in Freebase: “place of birth” and “place lived

location”. In DBpedia, who founded $organization? re-

lates to predicates founder and f ather.

PROBLEM DEFINITION 1. Given a question q, our goal is to

ﬁnd an answer v with maximal probability (v is a simple value):

arg max

P (V = v|Q = q) (1)

To illustrate how a value is found for a given question, we

proposed a generative model. Starting from the user question q,

we ﬁrst generate/identify its entity e according to the distribution

P (e|q). After knowing the question and the entity, we generate the

template t according to the distribution P (t|q, e). The predicate

p only depends on t, which enables us to infer the predicate p by

P (p|t). Finally, given the entity e and the predicate p, we generate

the answer value v by P (v|e, p). v can be directly returned or em-

bedded in a natural language sentence as the answer a. We illustrate

the generation procedure in Example 1, and shows the dependen-

cy of these random variables in Figure 4. Based on the generative

model, we compute P(q, e, t, p, v) in Eq (2). Now Problem 1 is

reduced to Eq (3).

P (q, e, t, p, v) = P (q)P (e|q)P (t|e, q)P (p|t)p(v|e, p) (2)

arg max

e,t,p

P (v|q, e, t, p) (3)

Figure 4: Probabilistic Graph

EXAMPLE 1. Consider the generative process of (q

, a

) in Ta-

ble 3. Since the only entity in q

is “Honolulu”, we generate the

entity node d (in Figure 1) by P (e = d|q = q

) = 1. By conceptu-

alizing “Honolulu” to a city, we generate the template How many

people are there in $city?. Note that the correspond-

ing predicate of the template is always “population”, no matter

which speciﬁc city it is. So we generate predicate “population” by

distribution P (p|t). After generating entity “Honolulu” and pred-

icate “population”, the value “390k” can be easily found from the

knowledge base in Figure 1. Finally we use a natural language

sentence a

as the answer.

Outline of the following subsections Given the above objective

function, our problem is reduced to the estimation of each prob-

ability term in Eq (2). The term P (p|t) is estimated in the ofﬂine

procedure in Sec 4. All other probability terms can be directly com-

puted by the off-the-shelf solutions (such as NER, conceptualiza-

tion). We elaborate the calculation of these probabilities in Sec 3.2.

And we elaborate the online procedure in Sec 3.3.

3.2 Probability Computation

In this subsection, we compute each probability term in Eq (2)

except P (p|t).

Entity distribution P (e|q) The distribution represents the enti-

ty identiﬁcation from the question. We identify entities that meet

both conditions: (a) it is an entity in the question; (b) it is in the

knowledge base. We use Stanford Named Entity Recognizer [13]

for (a). And we then check if it is an entity’s name in the knowledge

base for (b). If there are multiple candidate entities, we simply give

them uniform probability.

We optimize the computation of P (e|q) in the ofﬂine procedure

by q’s answer. As illustrated in Sec 4.1, we already extracted a set

of entity-value pairs EV

for question q

and answer a

, where the

values are from the answer. We assume the entities in EV

have

equal probability to be generated. So we obtain:

P (e|q

) =

[∃v, (e, v) ∈ EV

]

|{e

|∃v, (e

, v) ∈ EV

(4)

,where [.] is the Iverson bracket. As shown in Sec 7.5, this approach

is more accurate than directly using the NER approach.

Template distribution P (t|q, e) A template is in the form of

When was $person born?. In other words, it is a question

with the mention of an entity (e.g., “Barack Obama”) replaced by

the category of the entity (e.g., $person).

Let t = t(q, e, c) indicate that template t is obtained by replacing

entity e in q by e’s category c. Thus, we have

P (t|q, e) = P (c|q, e) (5)

, where P (c|q, e) is the category distribution of e in context q. In

our work, we directly apply the conceptualization method in [25]

to compute P (c|q, e).

Value (answer) distribution P (v|e, p) For an entity e and a

predicate p of e, it is easy to ﬁnd the predicate value v by look-

ing up the knowledge base. For example, in Figure 1, let entity

e = Barack Obama, and predicate p = dob. We easily get Oba-

ma’s birthday, 1961, from the knowledge base. In this case, we

have P (1961|Barack Obama, dob) = 1, since Barack Obama only

has one birthday. Some predicates may have multiple values (e.g.,

the children of Barack Obama). In this case, we assume uniform

probability for all possible values. More formalized, we compute

P (v|e, p) by

P (v|e, p) =

[(e, p, v) ∈ K]

|{(e, p, v

)|(e, p, v

) ∈ K}|

(6)

3.3 Online Procedure

In the online procedure, we are given a user question q

. We can

compute p(v|q

) by Eq (7). And we return arg max

P (v|q

) as

the answer.

P (v|q

) =

e,p,t

P (q

)P (v|e, p)P (p|t)P (t|e, q

)P (e|q

)

(7)

, where P (p|t) is derived from ofﬂine learning in Sec 4, and other

probability terms are computed in Sec 3.2.

Complexity of Online Procedure: In the online procedure, we

enumerate q

’s entities, templates, predicates, and values in order.

We treat the number of entities per question, the number of con-

cepts per entity, and the number of values per entity-predicate pair

as constants. So the complexity of the online procedure is O(|P |),

which is caused by the enumeration on predicate. Here |P | is the

number of distinct predicates in the knowledge base.

4. PREDICATE INFERENCE

In this section, we present how we infer predicates from tem-

plates, i.e., the estimation of P (p|t). We treat the distribution

P (P |T ) as parameters and then use the maximum likelihood (ML)

568

评论收藏

内容反馈

版权申诉

2201_75886486

2023-01-14

资源很受用，资源主总结的很全面，内容与描述一致，解决了我当下的问题。
weixin_47198280

2023-01-04

资源不错，对我启发很大，获得了新的灵感，受益匪浅。
weixin_45807041

2022-10-28

感谢大佬分享的资源给了我灵感，果断支持！感谢分享~
Neleas

2022-09-04

资源很实用，内容详细，值得借鉴的内容很多，感谢分享。
王定孔

2022-08-19

资源很赞，希望多一些这类资源。

前往

页

weixin_42132177

粉丝: 28
资源: 800

会员权益专享

智能问答系统python实现

Python聊天机器人，智能问答系统.zip

python智能问答系统.txt

智能问答系统的设计与实现

智能问答系统--对话篇

youmi:智能问答系统demo

Python知识自动问答系统的研究与实现

Python-该项目是基于医疗领域知识图谱的问答系统

基于python的自动问答系统.zip

基于python-flask实现的在线问答系统源码.zip

Python-基于Tensorflow的视觉问答系统VQA

在线问答系统

基于知识图谱的自动问答系统

Python实现通讯录功能

Python-手机网上答题系统

使用python实现人工智能算法

基于python的中科院分词实现

java在线问答系统

人工智能AI问答机器人

智能问答的聊天机器人系统的设计与实现

智能问答,自然语言处理相关资源与源码

python实现photoshop自动化

问答系统-问答网站源码

jQuery在线答题考试系统代码

人体姿态检测

抢购haiwei.rar

Python教程2020版 完全入门 达到Python工程师水平 笔记+代码+课件+资料

python大作业 含爬虫、数据可视化、地图、报告、及源码（2016-2021全国各地区粮食产量）.rar

会员权益专享

最新资源

Python教程2020版完全入门达到Python工程师水平笔记+代码+课件+资料

python大作业含爬虫、数据可视化、地图、报告、及源码（2016-2021全国各地区粮食产量）.rar