Joint learning of ontology and semantic parser from text

0.86 MB·

by  Janez Starc

November2015
Joint learning of ontology and semantic
parser from text
6
1
0
2 JanezSTARCa,1,DunjaMLADENIC´ a
n aJozˇefStefanInternationalPostgraduateSchool,Slovenia
a
J
Abstract.Semanticparsingmethodsareusedforcapturingandrepresentingse-
5
manticmeaningoftext.Meaningrepresentationcapturingalltheconceptsinthe

textmaynotalwaysbeavailableormaynotbesufficientlycomplete.Ontologies
]
provideastructuredandreasoning-capablewaytomodelthecontentofacollection
I
A oftexts.Inthiswork,wepresentanovelapproachtojointlearningofontologyand
semanticparserfromtext.Themethodisbasedonsemi-automaticinductionofa
.
s context-freegrammarfromsemanticallyannotatedtext.Thegrammarparsesthe
c textintosemantictrees.Both,thegrammarandthesemantictreesareusedtolearn
[
theontologyonseverallevels–classes,instances,taxonomicandnon-taxonomic
1 relations.TheapproachwasevaluatedonthefirstsentencesofWikipediapages
v describingpeople.
1 Keywords.ontologylearning,semanticparsing,grammarinduction,context-free
0 grammar
9
0
0
.
1 1. Introduction
0
6
One of the ultimate goals of Natural Language Processing (NLP) is machine reading
1
[1], the automatic, unsupervised understanding of text. One way of pursuing machine
:
v reading is by semantic parsing, which transforms text into its meaning representation.
i
X However,capturingthemeaningisnotthefinalgoal,themeaningrepresentationneeds
to be predefined and structured in a way that supports reasoning. Ontologies provide a
r
a common vocabulary for meaning representations and support reasoning, which is vital
for understanding the text. To enable flexibility when encountering new concepts and
relationsintext,inmachinereadingwewanttobeabletolearnandextendtheontology
whilereading.Traditionalmethodsforontologylearning[2,3]areonlyconcernedwith
discoveringthesalientconceptsfromtext.Thus,theyworkinamacro-readingfashion
[4],wherethegoalistoextractfactsfromalargecollectionoftexts,butnotnecessarily
allofthem,asopposedtoamicro-readingfashion,wherethegoalistoextracteveryfact
fromtheinputtext.Semanticparsersoperateinamicro-readingfashion.Consequently,
theontologieswithonlythesalientconceptsarenotenoughforsemanticparsing.Fur-
thermore, the traditional methods learn an ontology for a particular domain, where the
text is used just as a tool. On the other hand, ontologies are used just as tool to repre-
sent meaning in the semantic parsing setting. When developing a semantic parser it is
1Corresponding Author: Janez Starc, Jozˇef Stefan International Postgraduate School, Jamova 39, 1000
Ljubljana,Slovenia;E-mail:[email protected]
November2015
nottrivialtogetthebestmeaningrepresentationfortheobservedtext,especiallyifthe
contentisnotknownyet.Semanticparsingdatasetshavebeencreatedbyeitherselecting
textsthatcanbeexpressedwithagivenmeaningrepresentation,likeFree917dataset[5],
orbymanuallyderivingthemeaningrepresentationgiventhetext,likeAtisdataset[6].
In both datasets, each unit of text has its corresponding meaning representation. While
Free917usesFreebase[7],whichisaverybigmulti-domainontology,itisnotpossible
torepresentanarbitrarysentencewithFreebaseoranyotherexistingontology.
Inthispaper,weproposeanovelapproachtojointlearningofontologyandseman-
tic parsing, which is designed for homogeneous collections of text, where each fact is
usually stated only once, therefore we cannot rely on data redundancy. Our approach
is text-driven, semi-automatic and based on grammar induction. It is presented in Fig-
ure 1.The input is a seed ontology together with text annotated with concepts from the
seedontology.Theresultoftheprocessisanontologywithextendedinstances,classes,
taxonomic and non-taxonomic relations, and a semantic parser, which transform basic
unitsoftext,i.esentences,intosemantictrees.Comparedtotreesthatstructuresentences
based on syntactic information, nodes of semantic trees contain semantic classes, like
location,profession,color,etc.Ourapproachdoesnotrelyonanysyntacticanalysisof
text,likepart-of-speechtaggingordependencyparsing.Thegrammarinductionmethod
works on the premise of curriculum learning [8], where the parser first learns to parse
simple sentences, then proceeds to learn more complex ones. The induction method is
iterative,semi-automaticandbasedonfrequentpatterns.Acontext-freegrammar(CFG)
isinducedfromthetext,whichisrepresentedbyseverallayersofsemanticannotations.
ThemotivationtouseCFGisthatitisverysuitablefortheproposedalternatingusage
of top-down and bottom-up parsing, where new rules are induced from previously un-
parsableparts.Furthermore,ithasbeenshownby[9]thatCFGsareexpressiveenough
to model almost every language phenomena. The induction is based on a greedy iter-
ative procedure that involves minor human involvement, which is needed for seed rule
definition and rule categorization. Our experiments show that although the grammar is
ambiguous,itisscalableenoughtoparsealargedatasetofsentences.
The grammar and semantic trees serve as an input for the new ontology. Classes,
instancesandtaxonomicrelationsareconstructedfromthegrammar.Wealsoproposea
methodfordiscoveringlessfrequentinstancesandtheirclasses,andasupervisedmethod
tolearnrelationsbetweeninstances.Bothmethodsworkonsemantictrees.
Forexperimentation,firstsentencesofWikipediapagesdescribingpeoplearetaken
as a dataset. These sentences are already annotated with links to other pages, which
arealsoinstancesofDBpediaknowledgebase[10].UsingrelationsfromDBpediaasa
trainingset,severalmodelstopredictrelationshavebeentrainedandevaluated.
Therestofthepaperisorganizedinthefollowingway.Thegrammarinductionap-
proachispresentedinSection2.TheontologyinductionapproachfollowsinSection3.
InSection4wepresenttheconductedexperimentswithgrammarinduction,andinstance
andrelationextraction.WeexaminetherelatedworkinSection5,andconcludewiththe
discussioninSection6.
November2015
Layered text
representation
Semantic
Induction Parsing Semantic
Grammar trees
Class, instance, Instance and relation
Annotation
taxonomy extraction extraction
Seedontology Extended Induced
ontology
Figure1. Theproposedapproachtoontologyandgrammarinductiongetsacollectionoftextand
theseedontologyasinputandoutputsanewontology.Thecollectionoftextisfirstannotatedat
differentlevelsincludingannotationswiththeconceptsfromexistingontology.Theannotatedtext
isthenusedforgrammarinduction,wherethetextisrepresentedassemantictrees.Theseareused
togetherwiththegrammartoinduceanewontology.
2. Grammarinduction
In this section, we propose a semi-automatic bootstrapping procedure for grammar in-
duction, which searches for the most frequent patterns and constructs new production
rules from them. One of the main challenges is to make the induction in a way that
minimizeshumaninvolvementandmaximizesthequalityofsemantictrees.
Theinputtotheprocess,whichisillustratedinFigure2,isasetofpredefinedseed
grammar rules (see Section 2.5) and a sample of sentences in a layered representation
(see Section 2.1) from the dataset. The output of the process is a larger set of rules
forming the induced grammar. One rule is added to the grammar on each iteration. At
thebeginningofeachiterationallthesentencesareparsedwithatop-downparser.The
outputofparsingasinglesentenceisasemantictree–asetofsemanticnodesconnected
intoatree.Herewedistinguishtwopossibleoutcomesoftheparsing:1)thesentencewas
completelyparsed,whichisthefinalgoaland2)thereisatleastonepartofthesentence
that cannot be parsed. From the perspective of a parser the second scenario happens
when there is a node that cannot be parsed by any of the rules. We name these nodes
– null nodes – and they serve as the input for the next step, the rule induction. In this
stepseveralrulesareconstructedbygeneralizationofnullnodes.Thegeneralization(see
Section2.4)isbasedonutilizationofsemanticannotationsandbottom-upcomposition
oftheexistingrules.Outoftheinducedrules,arulewiththehighestfrequency(theone
that was generalized from the highest number of null nodes) is added to the grammar.
To improve quality of the grammar, the rules are marked by so called property, which
instructs the parser how to use the rule (eg., us it in parsing but not in induction). The
propertyvitallyaffectsresultoftheparsinginthefollowingiterationspotentiallycausing
ahugesemanticdriftfortherestofprocess.Consequently,ahumanuserneedstomark
November2015
thepropertyofeachrule.Theiterativeprocessrunsuntilapredefinedstoppingcriteria
ismet.Thecriteriaiseitherconnectedtothequalityofthegrammarortimelimitation.
For the sake of transparency of the experiments, the human is involved in the be-
ginning,whentheseedrulesarecreatedandlaterwhentherulepropertiesarespecified.
However, in another setting the user could also define new rules in the middle of the
bootstrappingprocedure.
Inthefollowingsections,wedescribeeachcomponentoftheprocessinmoredetails.
Layered text
representation Seed rules
Grammar Best rule
Property
Parsing
assignment
Incomplete
Semantic best rule
Rule Induction
trees Unparsablenodes
Figure2. Grammarinduction
2.1. Textualdatarepresentation
Theinputtextualdataneedstobeproperlystructuredinordertoworkbestwiththepro-
posedalgorithms.ShallowNLPtools,likesentencesplitting,wordtokenization,named
entityrecognition,mighthelpobtainingthisstructure.Thebasicunitisasentence,rep-
resented by several layers. An example is presented in Table 1. Each layer consists of
severaltokens,whichspanoveroneormorewords.Thebasiclayeristhelexicallayer,
whereeachtokenrepresentsasingleword.Allotherlayersarecreatedfromtheannota-
tions.Someannotations,likenamed-entities,mayspanoverseveralwords;someofthe
wordsmaynothaveanannotation,thustheyaregivenanulltoken.Itiscrucialthatall
algorithms are aware how to deal with a particular layer. For instance, the parser must
notbreakapartamulti-wordannotation.Somelayersmaybederivedfromothersusing
the seed ontology. For example, instance layer contains annotations to instances of the
ontology and the derived class layer represents the classes of these annotations, which
are also from the ontology. Annotation layers are valuable if they provide good means
forgeneralizationorconnectionwiththeontology.Atermisasubpartofthesentence,
definedbythestartingandendingpositioninthesentence.Ithasdifferentinterpretation
November2015
Layer Tokens
lexical Phil Madeira is a musician from Nashville
small-caps phil madeira is a musician from nashville
named-entity Person - - - - Location
Musical Nashville
instance PhilMadeira - - -
Artist Tennessee
class Person - - Profession - Location
Table1. Layeredrepresentationofasentence.Nulltokensareexpressedas”-”.
ineachlayer.Iftheinterpretationbreaksanyofthetokens,itisnotvalid.Forinstance,
termrepresentingMadeiraisnotvalidinnamed-entitylayerinTable1becauseitbreaks
Person.
2.2. GrammarDefinition
Ourcontext-freegrammarGisdefinedbythe5-tuple:G=(V,σ,P,S,R),where
• V is a set of non-terminals. Each non-terminal represents a semantic class, e.g.
(cid:104)Person(cid:105), (cid:104)Color(cid:105), (cid:104)Organization(cid:105). There is also a universal non-terminal (cid:104)∗(cid:105),
whichcanbereplacedbyanyothernon-terminal.Thesamenon-terminalreplaces
alloccurrencesinarule.Itisusedtorepresentseveralrules,withanotation.The
grammarisstillcontext-free.SeeseedruleexamplesinSection2.5.
• σ isasetofterminals.Terminalisanyexistingnon-nulltokenfromanysentence
layer.Wedenoteaterminalbyvalue{layer}.
Forinstance,[location]{named-entity},Phil Madeira{instance}.Iftheterminalis
fromthelexicallayer,thelayerisskippedinthedenotation.
• P is a set of production rules that represents a relation fromV →(V∪E)∗. For
example,
<Relation>::=<Person>is<LifeRole>
• S is the starting non-terminal symbol. Since non-terminals represent semantic
classes,thestartingsymbolischosenbasedonthesemanticclassoftheinputex-
amples.Iftheinputexamplesaresentences,thentheappropriatecategorymaybe
(cid:104)Relation(cid:105).Whileiftheinputexamplesarenounphrases,thestartingsymbolmay
beamorespecificcategory,like(cid:104)JobTitle(cid:105).
• R is a set of properties: positive, neutral, negative, non-inducible. The property
controlstheusageoftheruleintheparsingandintheruleinductionphase.More
detailsaregiveninthefollowingsubsections.
2.3. Parser
Forparsing,arecursivedescentparserwithbacktrackingwasdeveloped.Thisisatop-
down parser, which first looks at the higher level sentence structure and then proceeds
downtheparsetree toidentifylowleveldetailsofthe sentence.Theadvantageoftop-
downparsingistheabilitytopartiallyparsesentencesandtodetectunparsablepartsof
sentences.
The parser takes a layered sentence as an input and returns a semantic tree as an
output(seeFigure3).Therecursivestructureoftheprogramcloselyfollowsthestructure
November2015
of the parse tree. The recursive function Parse (see Algorithm 1) takes a term and a
non-terminal as input and returns a parse node as an output. The parse node contains
theclassofnode(non-terminal),therulethatparsedthenode,theterm,andthelistof
childrennodes.Inorderfortheruletoparsethenode,theleft-handsidemustmatchthe
inputnon-terminalandtheright-handsidemustmatchthelayeredinput.Inthepattern
matching function Match (line 6), the right hand side of a rule is treated like a regular
expression;non-terminalspresentthe(+)wildcardcharacters,whichmatchatleastone
word.Theterminalsaretreatedasliteralcharacters,whicharematchedagainstthelayer
that defines them. The result of successfully matched pattern is a list of terms, where
eachtermrepresentsanon-terminalofthepattern.Duetoambiguityofpatternmatching
theremightbeseveralmatches.Foreachoftheterm–non-terminalpairineverylistthe
parsefunctionisrecursivelycalled(line10).
1 Parse(Phrase p,Non-terminaln) output:parsenode
2 nodes←{};
3 foreachrulerof grammardo
4 ifn=leftsideofrthen
5 pattern←righthandsideofr;
6 ambiguous lists←Match(pattern, p);
7 foreachterm listof ambiguous listsdo
8 child nodes←{};
9 fori←0tosizeof term listdo
10 child node←Parse(term listi,pattern.non terminalsi);
11 addchild nodetochild nodes;
12 addNode(type, p,r,child nodes)tonodes;
13 ifnodesisemptythen
14 final node←Node(type, p,null,{});
15 else
16 final node←argmaxn∈nodesr(n);
17 iffinal nodeisnotfullyparsedthen
18 addfinal nodetoinduction nodes;
19 returnfinal node
Algorithm1:Pseudocodeofthemainfunctionparseofthetop-downparser.
Sincethegrammarisambiguous,atermcanbeparsedinmultipleways.Thereare
twotypesofambiguity.Twoormorerulescanexpandthesametermandonerulecan
expand the term in more than one way. For each ambiguity one node is created, and
thebestnodeaccordingtoreliabilitymeasureisselectedtobetheresult(line16).The
reliabilitymeasurer(n)is

1, ifnodeisfullyparsed
 ∑ |c|·r(c)
c∈C(n)
r(n)= β·(1−tp(n))+(1−β) , ifnodeispartiallyparsed (1)
∑ |c|
0, c∈C(n) ifnodeisnull
November2015
<Relation>
<Relation> ::= <Person> is <LifeRole>
Phil Madeira is a musician from Nashville
<Person> <LifeRole>
<Person> ::= Person{named-entity} <*> ::= a <*>
Phil Madeira a musician from Nashville
<LifeRole>
<LifeRole> ::= <LifeRole> from <Location>
musician from Nashville
<LifeRole> <Location>
<LifeRole> ::= [Profession]{class} <Location> ::= [Location]{class}
musician Nashville
Figure3. Anexampleofasemantictree,whichistheresultofparsingtheinputfromTable1.The
treeisfullyparsed.Eachnodehasthreerows:theclass,theruleandtheterminterpretedinthe
lexicallayer.
wheretp(n)isthetriggerprobabilityoftherulethatparsedthenoden,β isapredefined
weight,C(n)isthesetofchildrenofn,and|c|isthelengthofthetermofnodec.The
trigger probability of the rule is the probability that a the right-hand side of the rule
patternmatchesarandomterminthedatasetanditisestimatedaftertheruleisinduced.
The range of the measure is between 0 and 1. The measure was defined in such a way
thatthemoretextthenodeparses,thehigheristhereliability(thesecondsummandin
themiddlerowofEq.1).Ontheotherhand,nodeswithrulesthataremorefrequently
matched have lower reliability; this penalizes rules that are very loosely defined (the
firstsummandinthemiddlerowofEq.1).Theβ parameterwassetto0.05,usinggrid
search,withaverageF1scorefromrelationextractionexperimentfromSection4.4asa
performancemeasure.
If none of the rules match the term, a null node is created and added to the list of
nodes,whichwillbelaterusedforgrammarinduction(line18).Notethatevenifanull
nodeisdiscarded,becauseitisnotthemostreliable,itwillstillbeusedinthegrammar
induction step. A node is fully parsed if the node itself and all of its descendants are
parsed. If a node is parsed and if at least one of its descendants is not parsed, then the
node is partially parsed. All nodes that are not fully parsed are added to the list for
induction.
Sincetheambiguityofthegrammarmaymakeparsingcomputationallyinfeasible,
severaloptimizationtechniquesareused.Memoization[11]isusedtoreducethecom-
plexityfromexponentialtimetoO(n3)[12],wherenisthelengthofthesentence.The
parser does not support ε productions mainly because the grammar induction will not
produce them. The patterns that do not contain terminals are the most ambiguous. At
mosttwonon-terminalsareallowed,andthemaximallengthofthetermthatcorresponds
tothefirstnon-terminalisthreetokens.Wearguethatthisisnotahugelimitation,since
November2015
the way human languages are structured, usually two longer terms are connected with
a word, like comma or a verb. Furthermore, the way how our induction works, these
connectors do not get generalized and become a terminal in the rule. There was an at-
tempttointroduceruleswithnegativeproperty.Wheneversuchrulefullyparsesanode,
that indicates that the current parsing path is incorrect. This allows the parser to back-
tracksoonerandalsopreventsaddingnullsisternodes(nullsisternodesareinthiscase
usuallywrong)totheruleinduction.However,itturnedoutthatnegativerulesactually
slowdowntheparsing,sincethegrammargetsbigger.Itisbettertomarktheserulesas
neutral,thereforetheyarenotaddedtothegrammar.
2.4. Ruleinduction
Thegoaloftheruleinductionstepistoconvertthenullnodesfromtheparsingstepinto
rules.Outoftheserules,themostfrequentoneispromoted.Thetermfromthenullnode
isgeneralizedtoformtherightsideoftherule.Theclassnon-terminalofthenullnode
willpresenttheleftsideoftherule.Recentlyinducedrulewillparseallthenodes,from
whichitwasinduced,inthefollowingiterations.Additionally,somerulesmayparsethe
childrenofthosenodes.
Generalization
Generalizationisdoneintwosteps.First,termsaregeneralizedonthelayerlevel.The
outputofthisprocessisasequenceoftokens,whichmightbefromdifferentlayers.For
eachpositioninthetermasinglelayerisselected,accordingtopredefinedlayerorder.
In the beginning, term is generalized with the first layer. All the non-null tokens from
thislayeraretakentobepartofthegeneralizedterm.Allthepositionsofthetermthat
havenotbeengeneralizedareattemptedtobegeneralizedwiththenextlayer,etc.The
lastlayeriswithoutnull-tokens,thereforeeachpositionofthetermisassignedalayer.
Usually,thisisthelexicallayer.Forexample,toppartofTable2showsgeneralizationof
termfromTable1.Thelayerlistisconstructedmanually.Goodlayersforgeneralization
are typically those that express semantic classes of individual terms. Preferably, these
typesarenottoogeneral(lossofinformation)andnottoospecific(largergrammar).
In the next step of generalization, tokens are further generalized using a greedy
bottom-up parser using the rules from the grammar. The right sides of all the rules are
matched against the input token term. If there is a match, the matched sub-term is re-
placed withtheleftsideoftherule.Actually,ineachiterationallthedisjunctmatches
arereplaced.Togetonlythedisjunctmatches,overlappingmatchesarediscardedgreed-
ily,wherelongermatcheshavethepriority.Thisprocessisrepeateduntilnomorerules
matchtheterm.AnexampleispresentedinthelowerpartofTable2.
Thebottom-upparsingalgorithmneedstobefastbecausethenumberofunexpanded
nodescanbeveryhighduetoambiguitiesinthetop-downparsing.Consequently,theal-
gorithmisgreedy,insteadofexhaustive,andyieldsonlyoneresult.Aho-Corasickstring
matchingalgorithm[13]isselectedformatchingforitsabilitytomatchalltherulessi-
multaneously.Likethetop-downparser,thisparsergeneratespartialparsesbecausethe
bottom-upparserwillneverfullyparse–theoutputisthesameasthenon-terminaltype
intheunexpandednode.Thiswouldgenerateacyclicalrule,i.e.<Class>:==<Class>.
However,thisneverhappensbecausethetop-downparserwouldalreadyexpandthenull
node.
November2015
Layeredgeneralization
Person is a Profession from Location
class small-caps small-caps class small-caps class
Bottom-upparsing
Person is a <LifeRole>
class small-caps small-caps non-terminal
Table2. TwostepgeneralizationoftermfromTable1(PhilMadieraisamusicianfromNashville).
The layer list was constructed in a reverse order from Table 1. In this example, the rule <Life
Role>::=ProfessionfromLocationistheonlyrulethatwasusedinthebottom-upparsing.
Propertyassignment
Thelaststepoftheiterationisassigningthepropertytothenewlyinducedrule.Property
controlstheroleoftheruleintheparsingandinduction.Thedefaultpropertyispositive,
whichdefinesthedefaultbehavioroftheruleinallprocedures.Ruleswithneutralprop-
ertyarenotusedinanyprocedure.Theyalsocannotbere-induced.Somerulesaregood
forparsing,butmayintroduceerrorsintheinduction.Theserulesshouldbegivennon-
inducible property. For instance, rule <Date> :== <Number> is a candidate for the
non-inducibleproperty,sinceyearsarerepresentedbyasinglenumber.Onthecontrary,
noteverynumberisadate.
In our experiments, the assignment was done manually. The human user sees the
inducedruleandfewexamplesofthenullnodes,fromwhichitwasinduced.Thisshould
provide enough information for the user to decide in a few seconds, which property to
assign.Afterthestoppingcriteriaismet,theiterativeprocedurecancontinueautomati-
callybyassigningpositivepropertytoeachrule.Initialexperimentingshowedthatjusta
singlemistakeintheassignmentcancauseahugedrift,makingallfurtherruleswrong.
2.5. Seedrules
Before the start, a list of seed rules may be needed in order for grammar induction to
be successful. Since this step is done manually, it is reasonable to have a list of seed
rulesshortandefficient.Seedrulescanbedividedinthreegroups:domainindependent
linguisticrules,classrules,top-leveldomainrules.Domainindependentlinguisticrules,
suchas
< >::=a< > <Relation>::=<Relation>.
< >::=an< > < >::=< >and< >
< >::=the< > < >::=< >,< >and< >,
parsethetopandmid-levelnodes.Theycanbeappliedonmanydifferentdatasets.Class
rulesconnectclasstokens,likenamed-entitytokenswithnon-terminals.Forexample,
<Location>::=[location]{named-entity} <Date>::=[date]{named-entity}
<Location>::=[Location]{class} <Film>::=[Film]{class}
Theyparsetheleafnodesofthetrees.Ontheotherhand,top-leveldomainrules,define
thebasicstructureofthesentence.Forexample,
<Relation>::=<Person>is<LifeRole>
November2015
Asthenamesuggests,theyparsenodesclosetotheroot.Altogether,theserulegroups
parse on all levels of the tree, and may already be enough to parse the most basic sen-
tences,butmoreimportantly,theyprovidethebasisforlearningtoparsemorecomplex
sentences.
Thedecisiononwhichandhowmanyseedrulesshouldbedefinedreliesonhuman
judgmentwhetherthecurrentsetofseedrulesispowerfulenoughtoignitethebootstrap-
pingprocedure.Thisjudgmentmaybesupportedbyrunningoneiterationandinspecting
thetopinducedrules.
3. Ontologyinduction
Thissectiondescribeshowtoutilizethegrammarandmanipulatesemantictreestodis-
coverontologycomponentsinthetextualdata.
3.1. Ontologyinductionfromgrammar
Weproposeaprocedureformappinggrammarcomponentstoontologycomponents.In
particular,classes,instancesandtaxonomicrelationsareextracted.
First, we distinguish between instances and classes in the grammar. Classes are
represented by all non-terminals and terminals that come from a layer populated with
classes, for example, named-entity layer and class layer from Table 1. Instances might
alreadyexistintheinstancelayer,ortheyarecreatedfromrules,whoserighthandside
containsonlytokensfromthelexicallayer.Thesetokensrepresentthelabelofthenew
instance. For instance rule <Profession> ::= software engineer is a candidate for in-
stanceextraction.
Furthermore, we distinguish between class and instance rules. Class rules have a
singlesymbolrepresentingaclassontheright-handside.ClassrulesmaptosubClassOf
relationsintheontology.Iftheruleispositive,thentheclassontherightsideisthesub-
classoftheclassontheleftside.Forinstance,rule<Organization>::=<Company>
yieldsrelation(subClassOfCompanyOrganization).
Ontheotherhand,instanceruleshaveoneormoresymbolsrepresentinganinstance
ontherightside,anddefinetheisarelation.Iftheruleispositive,thentheinstanceon
therightsideisamemberofaclassontheleftside.Forinstance,rule<Profession>::=
softwareengineeryieldsrelation(isaSoftwareEngineerProfession).Ifclassorinstance
ruleisneutralthentherelationcanbetreatedasfalse.Notethatmanyotherrelationsmay
be inferred by combing newly induced relations and relations from the seed ontology.
Forinstance,inducedrelation(subClassOfnew-classseed-class)andseedrelation(isa
seed-classseed-instance)areusedtoinferanewrelation(isanew-classseed-instance).
Inthissection,wedescribedhowtodiscoverrelationsonthetaxonomiclevel.Inthe
nextsection,wedescribehowtodiscoverrelationsbetweeninstances.
3.2. Relationextractionfromsemantictrees
Weproposeamethodforlearningrelationsfromsemantictrees,whichtriestosolvethe
same problem as the classical relation extraction methods. Given a dataset of positive
relationexamplesthatrepresentonerelationtype,e.g.birthPlace,thegoalistodiscover
newunseenrelations.