GeneratingNaturalLanguageDescriptionsfromOWLOntologies:A ... · 2012. 12. 24. · Tecra A8 is a...

Generating Natural Language Descriptions fromOWLOntologies: ADetailed Presentation of the NaturalOWLSystem

Ion Androutsopoulos,1,2 Gerasimos Lampouras1 and Dimitrios Galanis1

1Department of Informatics, Athens University of Economics and Business, Greece2Digital Curation Unit – imis, Research Centre “Athena”, Athens, Greece

Abstract

We present Naturalowl, an open-source natural language generation system that produces texts describing individuals(e.g., products, museum exhibits) or classes of individuals from owl ontologies optionally associated with linguisticand user modeling resources. Unlike simpler owl verbalizers, which typically express a single axiom of the ontologyat a time in controlled and often not entirely fluent natural language mostly for the benefit of domain experts,we aim to generate fluent, coherent, and interesting multi-sentence texts appropriate for end-users (e.g., customers,museum visitors). A key benefit of using a system like Naturalowl on the Semantic Web is that it becomes possible topublish information in the form of owl ontologies, and rely on natural language generation to automatically producepersonalized texts in multiple languages from the ontologies, thus making the information easily accessible not onlyto computer programs and domain experts, but also to end-users. We discuss Naturalowl’s processing stages ofgenerating texts, the optional domain-specific linguistic and user modeling resources that can be used at each stage,why such resources are useful, and how they can be created and represented. We also report on trials we performed tomeasure the effort that is required to configure Naturalowl for new ontologies, and the quality of the resulting texts.

Key words: Semantic Web; natural language generation; ontologies; owl verbalizers; language resources; user modeling.

1. Introduction

The Semantic Web [20,155,6] is an effort to estab-lish standards and mechanisms that will allow com-puters to reason more easily about the semanticsof the Web’s resources (documents, data etc.), en-abling them and ultimately their users to share, lo-cate, and integrate resources more easily. Ontologiesplay a central role in this endeavour. Each ontologyprovides a conceptualization of a knowledge domain(e.g., consumer electronics) by defining the classesand subclasses of the domain’s individuals (entities),the types of possible relations between them etc.

The current standard to specify ontologies for theSemantic Web is owl, a formal language based ondescription logics [8], rdf, and rdf schema, with

owl2 being owl’s latest version [65]. 1 Given anowl ontology for a knowledge domain, it is possi-ble to publish machine-readable datasets pertain-ing to that domain (e.g., catalogues of products,their prices, features etc.) on the Web, with thedata having formally defined semantics based on theontology’s conceptualization. It is also possible tomark up Web resources (e.g., documents) with richmachine-readable meta-data, again with formallydefined semantics, to describe their authors, contentetc. In both cases, the datasets or meta-data provideinstances of the ontology’s concepts (e.g., particu-

1 Unless otherwise stated, we adopt owl2; consult

http://www.w3.org/TR/2009/REC-owl2-primer-20091027/

for an introduction. For background information on rdf

and rdf schema, see http://www.w3.org/TR/rdf-primer/.

Preprint December 24, 2012

lar individuals of its classes, particular instances ofits relation types). Extensions of existing owl on-tologies may also be published, for example to de-fine finer classes, or to combine concepts from sev-eral ontologies. Reasoning engines for owl are alsoavailable [68,163,156,129], and they can be used, forexample, to deduce additional information.

Following common practice in Semantic Web re-search, we use the term ontology to refer jointlyto (a) information that establishes a conceptualiza-tion of a knowledge domain, often called termino-logical knowledge or TBox, and (b) additional as-sertional knowledge, ABox, that describes particu-lar instances of the domain’s concepts. owl can ex-press knowledge of both types. Several semanticallyequivalent owl syntaxes have been developed. Peo-ple unfamiliar with formal knowledge representa-tion, however, often have difficulties understandingthem [143,53]. For example, the following statementdefines the class of St. Emilion wines, using owl’sfunctional-style syntax, one of the easiest to under-stand, which we also adopt throughout this article. 2

EquivalentClasses(:StEmilion

ObjectIntersectionOf(:Bordeaux

ObjectHasValue(:locatedIn :stEmilionRegion)

ObjectHasValue(:hasColor :red)

ObjectHasValue(:hasFlavor :strong)

ObjectHasValue(:madeFromGrape

:cabernetSauvignonGrape)

ObjectMaxCardinality(1 :madeFromGrape)))

The statement above defines StEmilion as theintersection of: (i) the class of Bordeaux wines; (ii)the class of all individuals whose locatedIn propertyhas (for each individual) stEmilionRegion among itsvalues (owl properties are generally many-valued);(iii)–(v) the classes of individuals whose hasColor,hasFlavor, and madeFromGrape property values includered, strong, and cabernetSauvignonGrape, respectively,without excluding wines that have additional valuesin these properties; and (vi) the class of individualswhose madeFromGrape property has exactly one value;hence, a St. Emilion wine is made exclusively fromCabernet Sauvignon grapes.

In this article, we provide a detailed description ofan open-source natural language generation (nlg)

2 Consult http://www.w3.org/TR/owl2-syntax/ for more

information on owl’s functional-style syntax. Naturalowlactually uses owl’s rdf/xml syntax, which can be con-

verted to functional-style and vice versa; see, for exam-

ple, http://owl.cs.manchester.ac.uk/converter/. We of-ten use examples loosly inspired from the Wine Ontology,

which we discuss in Section 4.1.

system, called Naturalowl, that produces texts de-scribing classes or individuals of owl ontologies. 3

For example, the system can automatically generatethe following text from the owl statement above,if the ontology has been annotated with domain-specific linguistic resources (e.g., lexicon entries,sentence plans) that we discuss below.

St. Emilion is a kind of Bordeaux from the St. Emilion

region. It has red color and strong flavor. It is made from

exactly one grape variety: Cabernet Sauvignon grapes.

Naturalowl currently supports both English andGreek. 4 Hence, Greek texts can also be generatedfrom the same ontology, provided that it has alsobeen annotated with appropriate Greek linguisticresources. For example, given the following prod-uct description in owl, the English and Greek textsshown below can be generated.

ClassAssertion(:Laptop :tecraA8)

ObjectPropertyAssertion(:manufacturedBy

:tecraA8 :toshiba)

ObjectPropertyAssertion(:hasProcessor

:tecraA8 :intelCore2)

DataPropertyAssertion(:hasMemoryInGB

:tecraA8 "2"^^xsd:nonNegativeInteger)

DataPropertyAssertion(:hasHardDiskInGB


DataPropertyAssertion(:hasSpeedInGHz

:tecraA8 "2"^^xsd:float)

DataPropertyAssertion(:hasPriceInEuro


Tecra A8 is a laptop, manufactured by Toshiba. It has

an Intel Core 2 processor, 2 gb ram and an 110 gb hard

disk. Its speed is 2 ghz and it costs 850 Euro.

O Tecra A8 eÐnai ènac forhtìc upologist c, kataskeuasmè-

noc apì thn Toshiba. Diajètei epexergast Intel Core 2,

2 gb ram kai sklhrì dÐsko 110 gb. H taqÔtht� tou eÐnai

2 ghz kai kostÐzei 850 Eur¸.

For readers unfamiliar with owl, we note thatan object property (e.g., manufacturedBy) maps an in-dividual (e.g., tecraA8) to one or more individuals(e.g., toshiba), whereas a datatype property (e.g.,hasMemoryInGB) maps an individual to one or moredatatype values (e.g., strings, numbers). We followthe convention that class identifiers start with capi-tals, whereas the identifiers of individuals and prop-erties start with lower-case letters. To save space, weomit the definitions of common namespaces; for ex-

3 A much shorter description of an earlier version of Natu-ralowl has also been published [60]. An earlier version of thesystem has been demonstrated at major conferences [86,61].4 We welcome collaborations to support other languages.

2

ample, xsd is a common abbreviation for the names-pace http://www.w3.org/2001/XMLSchema.

The examples above illustrate how nlg can helppublish information on the Web both as owl state-ments and as texts generated from the owl state-ments; the generated texts can also be turned intohtml pages, including images of the individuals etc.This way, information becomes easily accessible toboth computer applications, which can process theowl statements, and end-users speaking differentlanguages. Changes in the owl statements can beautomatically reflected in the texts by regeneratingthem. Other well-known benefits of nlg include theability to tailor the texts per user type. For example,in a machine-generated text describing a medicine[30], doctors may wish to see more specialized in-formation than non-experts, who may need textswith more background knowledge, expressed in sim-pler terms. The texts can also vary depending onthe user’s interaction history, for example to avoidrepeating information or to include comparisons topreviously encountered individuals. 5

Although nlg from symbolic information is an es-tablished area [116,145,16,100], Naturalowl is cur-rently one of the very few nlg systems for owl;we compare to related systems below. We also notethat Naturalowl aims to generate fluent, coherent,and interesting multi-sentence texts appropriate forend-users (e.g., museum visitors, customers of on-line shops), unlike simpler systems often called on-tology verbalizers [151]. The latter usually translatethe ontology’s axioms (in our case, owl statements)one by one to controlled and often not entirely flu-ent English statements, typically without consider-ing the coherence of the resulting texts, the inter-ests of the readers, or their interaction histories, andmostly for the benefit of domain experts. Convey-ing the exact meaning of all the axioms is consid-ered more important in ontology verbalizers thancomposing fluent, coherent, and interesting texts.By contrast, Naturalowl may not express informa-tion that a particular end-user presumably alreadyknows, and it may opt for more fluent, but techni-cally less precise phrasings. Furthermore, it includesmechanisms to order sentences, aggregate them intolonger ones, generate referring expressions etc. Wereturn to owl verbalizers below, where we also com-pare Naturalowl’s texts to those of a verbalizer.

5 We do not discuss how Naturalowl generates compar-isons in this article, but see Milosavljevic [126], Isard [81],

Karakatsiotis [85], and Marge et al. [115] for related work.

Naturalowl is intended to generate texts describ-ing individuals (or classes of individuals) such asphysical objects, organizations, or persons. It is notintended to describe sequences of events [10,91], norto produce instructions to perform tasks [75,76,167],or reports from numerical data [179,17]. Also, wedo not discuss generating spoken descriptions [162],although Naturalowl was recently used in spokendialogues with robotic museum guides [96,169,97].Our work is based on ideas from ilex [132] and m-piro [82]. The ilex project developed an nlg sys-tem that was demonstrated mostly with museum ex-hibits, but did not support owl; Dale et al. [38] andDannels [43] also discuss nlg for museums. The m-piro project produced a multilingual extension ofilex’s system, which was tested in several domains,including museum exhibits and computing equip-ment [4]. Attempts to use m-piro’s generator withowl ontologies, however, ran into problems, becauseof incompatibilities between owl and m-piro’s on-tological model [2]. By contrast, Naturalowl wasespecially developed for owl.

Naturalowl can be used with different domainontologies, but the resulting texts may not soundfluent, coherent, or interesting enough, until appro-priate domain-specific linguistic and user modelingresources, hereafter called domain-dependent gen-eration resources, have been created. For example,the ontology’s classes can be mapped to natural lan-guage names, the ontology’s properties to sentenceplans, other resources may indicate which sentenceplans to prefer per user type etc. The domain-dependent generation resources are created by aperson we call the domain author, when the systemis configured for a new ontology. Similar resourcesare used in most nlg systems for symbolic informa-tion. Naturalowl’s domain-dependent generationresources can be created using a plug-in of theProtege ontology editor. 6 The plug-in also allowsNaturalowl to be invoked within Protege (Figure1). We do not discuss the plug-in in any detail in thisarticle, since it is very similar to m-piro’s authoringtool, which has been presented elsewhere [4]. 7

6 See http://protege.stanford.edu/ for information onProtege. Naturalowl and its Protege plug-in are freely avail-

able from http://nlp.cs.aueb.gr/software.html.7 We describe Naturalowl version 2 in this article. Version 1

used a less principled representation of its domain-dependentgeneration resources. m-piro’s authoring tool, now calledeleon [23], can currently be used only with Naturalowl

version 1; see http://users.iit.demokritos.gr/∼eleon/.

3

Figure 1. Invoking Naturalowl within Protege. An English

description of an individual has been generated.

Different nlg systems often adopt different lin-guistic theories, generation algorithms, and usermodels, thus requiring different domain-dependentgeneration resources. There is currently little con-sensus on exactly what information the domain-dependent generation resources should capture, orhow this information should be represented. In thespirit of the Semantic Web, however, it seems rea-sonable to expect that when generating texts fromowl ontologies, the domain-dependent generationresources themselves should be instances of otherowl ontologies, with each ontology of the latterkind defining the types of resources required bya particular nlg system. To avoid confusion, wehereafter use the term domain ontology to refer tothe ontology whose individuals and classes are de-scribed, as opposed to the generation resources on-tology that defines the types of domain-dependentgeneration resources a particular nlg system, in ourcase Naturalowl, requires. 8 By representing thedomain-dependent generation resources in owl, itbecomes easier to publish them on the Web, reusethem, check them for inconsistencies using owlreasoners etc. as with other owl ontologies.owl ontologies often use English words or con-

catenations of words (e.g., manufacturedBy) as identi-fiers of classes, properties, and individuals. Hence,some of the domain-dependent generation resources

8 See also Cimiano et al. [34], Montiel-Ponsoda et al. [127],and Gracia et al. [64] for discussion on associating liguistic

resources with ontologies. Mellish [119] suggests represent-ing in owl the abstract nlg architecture of rags [123]. Theresources of every rags-compliant nlg system could then

be represented in owl, using specializations of abstract con-cepts from rags’s architecture. We note, however, that the

rags architecture is deliberatively very high level, and sub-

stantial work would be necessary to establish exactly howthe processing stages and resources of Naturalowl or other

nlg systems relate to rags concepts.

can often be extracted from the domain ontologies.For example, Sun and Mellish [159,160] use Word-Net [56] and some heuristics to split the identifiersof classes and properties into English words, and toassign them part-of-speech (pos) tags. This allowsguessing that a class identifier like Laptop in our ear-lier example is a noun that can be used to refer tothat class, or that a statement of the form:

ObjectPropertyAssertion(:manufacturedBy X Y )

should be expressed in English as a sentence of theform “X was manufactured by Y ”. Most owl ver-balizers follow the same strategy.

If domain-dependent generation resources arenot provided, Naturalowl adopts a similar behav-ior. It attempts to guess the resources from thedomain ontology, or it uses generic resources. Theresulting texts, however, are of lower quality, com-pared to those generated with appropriate domain-dependent generation resources, and closer to theoutput of ontology verbalizers. For example, thelaptop description of page 2 becomes:

Tecra A 8 is a laptop. Tecra A 8 manufactured by Toshiba.

Tecra A 8 has processor Intel Core 2. Tecra A 8 has

memory in gb 2. Tecra A 8 has hard disk in gb 110. Tecra

A 8 has speed in ghz 2. Tecra A 8 has price in Euro 850.

The sentences are now less fluent, because they arebased on templates (e.g., “X has price in Euro Y ”)extracted directly from the domain ontology, insteadof better sentence plans that would have been spec-ified by a domain author (e.g., “X costs Y Euro”).Sentences with the same subject and verb are nolonger aggregated, because Naturalowl does notknow which words are verbs, information that wouldbe present in the sentence plans and lexicon entriesprovided by the author. Without appropriate lexi-con entries, the system also no longer knows the gen-der of laptops; hence, it refrains from using personalpronouns (e.g., “it”). Furthermore, Greek texts can-not be generated, because the domain ontology’sidentifiers are English-like.

Extracting domain-dependent generation re-sources from the domain ontology reduces theeffort needed to configure Naturalowl for a newdomain; hence, this approach is appealing whenthe texts do not need to be particularly fluent,coherent, nor personalized, and a single languagesuffices. On the other hand, most of Naturalowl’sdomain-dependent generation resources are asso-ciated with classes and properties of the domainontology (TBox), rather than individuals (ABox);

4

consequently, when there are relatively few classesand properties, many more individuals, and thetexts need to be fluent, coherent, personalized, orin multiple languages, authoring domain-dependentgeneration resources may be preferable. There is atradeoff between investing less effort to constructdomain-dependent generation resources and ob-taining higher-quality texts in multiple languages.

To the best of our knowledge, this article is thefirst detailed description of a complete general-purpose nlg system for owl, excluding simplerontology verbalizers. The article also discusses trialswe conducted with two independently created owldomain ontologies to assess our system’s porta-bility to ontologies created by others, the effortthat is required to construct Naturalowl’s domain-dependent generation resources, and the gain intext quality, as opposed to using a verbalizer orNaturalowl without domain-dependent generationresources. We believe these trials are also novel.

Overall, the main contributions of this articleare: (i) it is the first (excluding verbalizers) de-tailed description of a complete, general-purpose,open-source nlg system for owl domain ontolo-gies; (ii) it shows how the same system can producerough-quality texts for end-users directly from owldomain ontologies, but also how additional domain-dependent generation resources can improve thequality of the texts, help personalize them, and gen-erate them in multiple languages; (iii) it shows howthe domain-dependent generation resources them-selves can be represented in owl; (iv) it reports ontrials with two independently created owl domainontologies, where the texts of our system, with andwithout domain-dependent generation resources,were compared against those of a simpler verbalizer.The article does not present novel algorithms froma theoretical nlg perspective. In fact, some of thealgorithms that Naturalowl employs are of a muchnarrower scope, compared to more fully-fledged nlgalgorithms. Nevertheless, the trials show that thesystem produces texts of reasonable quality, espe-cially when domain-dependent generation resourcesare provided. We hope that if Naturalowl con-tributes towards a wider adoption of nlg methodson the Semantic Web, other researchers may wish todevelop improved components of the system, basedon more elaborate algorithms. 9 To this end, we

9 A collaborative source code repository for Naturalowl is

available at http://naturalowl.sourceforge.net/.

propose several ways to extend the current system,also pointing to the prominent relevant literature.

Section 2 below explains how Naturalowl gener-ates texts; it also discusses the domain-dependentgeneration resources. Section 3 presents relatedwork. Section 4 describes the trials we performed.Section 5 concludes and proposes future work.

2. Processing stages and resources

Naturalowl adopts a pipeline architecture, whichis common in nlg [145], though the number and ex-act purpose of the pipelined components often vary[123]. Our system generates texts in three stages,document planning, micro-planning, and surface re-alization, discussed in the following sections.

2.1. Document planning

Document planning consists of two sub-stages:content selection, where the system selects the logi-cal facts to convey, and text planning, where it plansthe structure of the text to be generated.

2.1.1. Content selectionIn content selection, the system retrieves from the

domain ontology candidate facts, it converts themto message triples, which are easier to express assentences, and it then selects among the candidatemessage triples the ones to be expressed.

Candidate facts for individual targetsLet us first consider content selection when Natu-

ralowl is asked to describe an individual (an entity),and let us call target the individual being described.The system scans the owl statements of the domainontology, looking for statements of the forms listedin Table 1, which are considered candidate facts, i.e.,facts that could be mentioned. 10 We have alreadyused most kinds of statements of Table 1 in thelaptop example of page 2; SameIndividual(X Y ) andDifferentIndividuals(X Y ) signal that X and Y denotethe same or different individuals. 11 Negative prop-erty assertions (e.g., stating that a particular lap-top is not manufactured by a particular company)

10Naturalowl scans the domain ontology using owl api;

consult http://owlapi.sourceforge.net/.11These statements and some others that we show as havingtwo arguments can actually have more arguments, but they

can be converted to binary statements.

5

√ClassAssertion(Class target )

√ObjectPropertyAssertion(objProp target indiv )

√DataPropertyAssertion(dataProp target dataValue )

× negative property assertions√

DifferentIndividuals(target indiv )

√DifferentIndividuals(indiv target )

√SameIndividual(target indiv )

√SameIndividual(indiv target )

Table 1owl statements used (

√) or not (×) as candidate facts,

when generating a text for an individual whose identifieris target . Class is either a class identifier or an expression

constructing an unnamed class using the operators of Ta-

ble 2; objProp and dataProp stand for object and datatypeproperties, respectively; indiv is the identifier of an individ-

ual; and dataValue is a datatype value.

are also allowed in owl2, but they are currently notsupported by Naturalowl; they are also rarely used.

We note that ClassAssertion(Class target ) state-ments may be quite complex, because Class is notnecessarily a class name. It may also be an expres-sion that constructs a new, unnamed class using op-erators from Table 2, as in the following example.

ClassAssertion(

ObjectIntersectionOf(:Wine






ObjectMaxCardinality(1 :madeFromGrape))

:chateauTeyssier2007)

The statement above says that chateauTeyssier2007

is an individual wine with the same characteris-tics as the StEmilion wines of page 2, except that itis not necessarily a Bordeaux. Notice that here thestatement mentions the broader class Wine, insteadof its subclass Bordeaux; it also uses an unnamedclass as the first argument of the ClassAssertion. As-suming that the target is chateauTeyssier2007, Natu-ralowl could express the owl statement above bygenerating a text like the following. The exact textwould depend on the domain-dependent generationresources.

The 2007 Chateau Teyssier is a wine from the Saint-

Emilion region. It has red color and strong flavor. It is

made from exactly one grape variety: Cabernet Sauvignon

grapes.

Notice that a single ClassAssertion gives rise to mul-tiple sentences. The order of the sentences is not nec-essarily the same as that of the corresponding owl

(i) Multi-class operators (MultiClassOper):√

ObjectIntersectionOf(

{NamedClass | SingleClassOper }+)

× ObjectIntersectionOf(... MultiClassOper ...)

√ObjectUnionOf({NamedClass | SingleClassOper }+)

× ObjectUnionOf(... MultiClassOper ...)

(ii) Single-class operators (SingleClassOper):√

ObjectComplementOf(NamedClass )

× ObjectComplementOf(UnnamedClass )

√ObjectOneOf(indiv+)

√ObjectHasValue(objProp indiv )

√ObjectHasValue(dataProp dataValue )

√ObjectHasSelf(objProp )

√ObjectMaxCardinality(number prop [NamedClass ])

× ObjectMaxCardinality(number prop UnnamedClass )

√ObjectMinCardinality(number prop [NamedClass ])

× ObjectMinCardinality(number prop UnnamedClass )

√ObjectExactCardinality(number prop [NamedClass ])

× ObjectExactCardinality(number prop UnnamedClass )

√ObjectSomeValuesFrom(objProp NamedClass )

× ObjectSomeValuesFrom(objProp UnnamedClass )

√ObjectAllValuesFrom(objProp NamedClass )

× ObjectAllValuesFrom(objProp UnnamedClass )

Table 2

owl operators that may (√

) or may not (×) be used toconstruct unnamed classes when using Naturalowl. Ex-

pressions marked with ‘+’ may be repeated, ‘|’ denotes a dis-

junction, and square brackets indicate optional arguments.NamedClass is a class identifier; UnnamedClass is an expres-

sion constructing an unnamed class; MultiClassOper andSingleClassOper are expressions starting with operators of

the corresponding types; objProp is an object property,

dataProp a datatype property, prop any property, indiv anindividual’s identifier, and dataValue a datatype value.

expressions inside the ClassAssertion; sentences areordered during text planning.

owl allows arbitrarily many nested ObjectUnionOf

(class union) and ObjectIntersectionOf (class inter-section) operators, which may lead to statementsthat are very difficult to express in natural language.To simplify text generation and to ensure that theresulting texts are reasonably easy to comprehend,we do not allow nested ObjectIntersectionOf andObjectUnionOf operators in the domain ontologiesthat Naturalowl is used to generate texts from. InTable 2 (part i), this restriction is enforced by notallowing what we call multi-class operators (opera-

6

tors with more than one class arguments), namelyObjectIntersectionOf and ObjectUnionOf) inside thearguments of other multi-class operators. For thesame reasons, i.e., to simplify the generation processand produce texts that are easier to comprehend,we do not allow unnamed classes inside some otheroperators, as shown again in Table 2 (part ii). If adomain-ontology violates the constraints of Table 2,it can be easily modified to comply with the con-straints by defining new named classes for nestedunnamed classes. The owl ontologies we have en-countered so far did not violate the constraints.See Power et al. [137,141] for a study of the owlstatements ontology authors use most frequently.

For the benefit of readers unfamiliar with owl,let us quickly explain the operators of Table 2we have not used so far. ObjectComplementOf con-structs the class of all individuals not in the originalclass. ObjectOneOf constructs a class by enumer-ating all of its individuals. ObjectHasValue(objProp

indiv ) denotes the class of individuals that haveindiv among the values of their objProp property;recall that owl’s properties are generally many-valued. As a special case, ObjectHasSelf(objProp )

is the class of individuals that have themselves asone of the (possibly many) values of their objProp .ObjectMaxCardinality(number prop ) denotes the classof individuals that have (each) no more than number

values in their prop property. ObjectMinCardinality

and ObjectExactCardinality are similar, but theyspecify the minimum or exact number of values.In all three cardinality operators, an optional thirdargument specifying a class may be present; thenthe restriction refers to values from the third ar-gument’s class. For example, the following is theclass of individuals that are made from at most oneItalian grape and any number of other grapes.

ObjectMaxCardinality(1 :madeFromGrape :ItalianGrape)

Finally, ObjectSomeValuesFrom(objProp Class ) is theclass of individuals that have at least one memberof Class among the values of their objProp . For ex-ample, the following is the class of individuals thatmanufacture (each) at least one laptop.

ObjectSomeValuesFrom(:manufactures :Laptop)

Similarly, ObjectAllValuesFrom(objProp Class ) is theclass of individuals that do not have values out-side Class in their objProp , including individuals thathave no values at all in objProp .

Recall that Naturalowl’s texts are intended to beread by end-users. Hence, we prefer to generate textsthat may not emphasize enough, from a knowledge

representation point of view, some of the subtletiesof owl’s statements, in order to produce more read-able texts. An owl expert might prefer, for ex-ample, the following natural language descriptionof chateauTeyssier2007, which mirrors more closelythe corresponding owl statements, than the text ofpage 6. The text below also makes it clearer that,in the absence of other information, nothing rulesout the possibility that chateauTeyssier2007 may, forexample, have both a strong and another flavor.

The 2007 Chateau Teyssier is a member of the intersec-

tion of the following classes: (a) the class of wines, (b) the

class of individuals from (not necessarily exclusively) the

St. Emilion region, (c) the class of individuals that have

(not necessarily exclusively) red color, (d) the class of in-

dividuals that have (not necessarily exclusively) strong

flavor, (e) the class of individuals that are made exclu-

sively from Cabernet Sauvignon grapes.

Stricter texts of this kind, however, seem inappro-priate for end-users. In fact, it could be argued thatmentioning that the 2007 Chateau Teyssier is madefrom exactly one grape variety in the text of page 6is also inappropriate for end-users. Naturalowl canbe instructed to avoid mentioning this informationvia user modeling annotations, discussed below.

Candidate facts for class targetsWe have so far discussed how Naturalowl se-

lects candidate facts when asked to describe an in-dividual. If the system is asked to describe a class,it scans the domain ontology for statements of theforms of Table 3; the class to be described must be anamed one, meaning that it must have an owl iden-tifier, and Target is its identifier. 12 A statement ofthe form DisjointClasses(Class1 Class2 ) signals thatClass1 and Class2 can never have a common individ-ual. Again, to simplify the generation process and toavoid producing complicated texts, we require botharguments of DisjointClasses to be named classes.Statements violating this restriction can be trans-formed by defining new named classes.

In texts describing classes, it is difficult to expressinformally the difference between EquivalentClasses

and SubClassOf. EquivalentClasses(Class1 Class2 )

12SubClassOf(NamedClass Target ) statements could also be

selected as candidate facts. They would lead to sentencesnaming subclasses of Target , as in the following text where

the target is the class of vases: “A vase was used to store food

or liquids. Known types of vases are: hydriae, amphorae, andlekythoi.” Similarly, known individuals of a target class (or

some of them) could be mentioned.

7

√EquivalentClasses(Target Class )

√EquivalentClasses(Class Target )

√SubClassOf(Target Class )

√DisjointClasses(Target NamedClass )

× DisjointClasses(Target UnnamedClass )

√DisjointClasses(NamedClass Target )

× DisjointClasses(UnnamedClass Target )

Table 3owl statements used (

√) or not (×) as candidate facts when

generating a text for a class whose identifier is Target . Classcan be either a class identifier or an unnamed class con-

structed with the operators of Table 2. Statements marked

with ‘×’ can be tranformed to use named classes.

means that any individual of Class1 also belongs inClass2 , and vice versa. By contrast, SubClassOf(Class1Class2 ) means that any member of Class1 also be-longs in Class2 , but the reverse is not necessarilytrue. If we replace EquivalentClasses by SubClassOf

in the definition of StEmilion of page 2, as shownbelow, then any member of StEmilion is still neces-sarily also a member of the intersection, but a winewith all the characteristics of the intersection is notnecessarily a member of StEmilion.

SubClassOf(:StEmilion

ObjectIntersectionOf(:Bordeaux






ObjectMaxCardinality(1 :madeFromGrape)))

Consequently, one should perhaps add sentences likethe ones shown in italics below, when expressingEquivalentClasses and SubClassOf, respectively. 13




Every St. Emilion has these properties, and anything that

has these properties is a St. Emilion.




Every St. Emilion has these properties, but something may

have these properties without being a St. Emilion.

13Power and Third [141] use “X is defined as” with

EquivalentClasses, and presumably expressions like “everyX is a” with SubClassOf. Cregan et al. [36] use “is fully de-fined as” and “is partly defined as”, respectively. We suspect

that the difference would still be unclear to end-users.

Although it is trivial to add the sentences shownin italics, Naturalowl currently produces the sametexts, without the sentences in italics, for bothEquivalentClasses and SubClassOf, in order to avoidgenerating texts that sound too formal. Further-more, the system may not mention some of thedomain ontology’s information about a target class(e.g., that a St. Emilion has strong flavor), whenuser modeling indicates that this information isalready known or that the text should not exceeda particular length. Hence, strictly speaking theresulting texts generally express necessary, not suf-ficient conditions for individuals to belong in thetarget class. This behavior is consistent with thefact that when asked to describe an individual,rather than a class, the system does not necessarilyconvey all the information it knows about the in-dividual, in order to comply with space constraintsand other user modeling requirements.

Additional candidate factsIn some applications, expressing additional facts

that are indirectly related to the target may be desir-able. Let us assume, for example, that the target isan individual whose identifier is exhibit24, and thatthe content selection mechanisms discussed abovehave retrieved the following candidate facts from thedomain ontology. Naturalowl would express themby generating a text like the one below.

ClassAssertion(:Aryballos :exhibit24)

ObjectPropertyAssertion(:locationFound

:exhibit24 :heraionOfDelos)

ObjectPropertyAssertion(:creationPeriod

:exhibit24 :archaicPeriod)

ObjectPropertyAssertion(:paintingTechniqueUsed

:exhibit24 :blackFigureTechnique)

ObjectPropertyAssertion(:currentMuseum

:exhibit24 :delosMuseum)

This is an aryballos, found at the Heraion of Delos. It

was created during the archaic period and it was deco-

rated with the black-figure technique. It is currently in

the Museum of Delos.

The natural language names of classes and individ-uals can be shown as hyperlinks to indicate thatthey can be used as subsequent targets. Clickingon a hyperlink would be a request to describe thecorresponding class or individual. 14 Alternatively,we may retrieve the candidate facts of these possi-

14Similar hyperlinks were used, for example, in demonstra-

tors of ilex and m-piro [132,82,4], the system described byDale et al. [38], and that of Halaschek-Wiener et al. [69].

They are also used by some owl verbalizers [178].

8

ble subsequent targets in advance and add them tothose of the current target.

More precisely, assuming that the target is anindividual, the subsequent possible targets, calledsecond-level targets, are taken to be the target’sclass, provided that it is a named one, and theindividuals the target is directly linked to via ob-ject properties. Naturalowl considers second-leveltargets only when the current target is an individ-ual, because expressing information about possiblesubsequent targets when the current target is aclass often leads to complicated texts. The systemcan be set to retrieve candidate facts for both thecurrent and the second-level targets (when applica-ble), or only for the current target; we say that themaximum fact distance is two or one, respectively.

Returning to exhibit24, let us assume that themaximum fact distance is two and that only the fol-lowing candidate facts for second-level targets areavailable; we explain the owl statements below. 15

SubClassOf(:Aryballos :Vase)

SubClassOf(:Aryballos

ObjectHasValue(:exhibitTypeCannedDescription

"An aryballos was a small spherical vase with a

narrow neck, in which the athletes kept the oil

they spread their bodies with"^^xsd:string))

DatatypePropertyAssertion(:periodDuration

:archaicPeriod "700 BC to 480 BC"^^xsd:string)

DatatypePropertyAssertion(:periodCannedDescription

:archaicPeriod "The archaic period was when the

Greek ancient city-states developed"^^xsd:string)

DataPropertyAssertion(:techniqueCannedDescription

:blackFigureTechnique "In the black-figure

technique, the silhouetes are rendered in black

on the pale surface of the clay, and details are

engraved"^^xsd:string)

Notice that we associated the Aryballos class withthe string “An aryballos. . . bodies with” by usingan ObjectHasValue inside a SubClassOf statement; ineffect, the statement says that every individual ofthe Aryballos class has that string as the value of itsexhibitTypeCannedDescription property. We could nothave associated the class directly with the string viaa property assertion, as we did with the archaicPeriod

and blackFigureTechnique individuals, because owl’sproperties map only from individuals, not classes,to datatype values or other individuals.

To express all the candidate facts, Naturalowlwould now generate a text like the following, whichmay be preferable, if this is the first time the userencounters an aryballos and archaic exhibits.

15Consult http://www.w3.org/TR/owl-time/ for more prin-

cipled representations of time in owl.

This is an aryballos, a kind of vase. An aryballos was

a small spherical vase with a narrow neck, in which the

athletes kept the oil they spread their bodies with. This

particular aryballos was found at the Heraion of Delos

and it was created during the archaic period. The archaic

period was when the Greek ancient city-states developed

and it spans from 700 bc to 480 bc. This aryballos was

decorated with the black-figure technique. In the black-

figure technique, the silhouetes are rendered in black on

the pale surface of the clay, and details are engraved. This

aryballos is currently in the Museum of Delos.

We note that in many domain ontologies it is im-practical to represent all the information in purelylogical terms. In our example, it is much easierto store the information that “An aryballos wasa small. . . spread their bodies with” directly as astring, i.e., as a canned sentence in nlg terminol-ogy, as opposed to defining classes, properties, andindividuals for spreading actions, bodies, athletes,etc. and generating the sentence from a logicalmeaning representation. Similar comments apply tothe other canned sentences in the example above. Adisadvantage of using canned sentences is that theymay have to be entered in multiple versions, if sev-eral languages or user types need to be supported.Some of the advantages of nlg are still available,however, when the canned sentences are propertyvalues of the domain ontology as above. For exam-ple, the canned sentences can still be placed at ap-propriate positions in the overall text, as with sen-tences generated from purely logical facts, and someof their referring expressions (e.g., pronouns) canbe automatically produced, as we discuss below. 16

Limitations of content selectionApart from the restrictions of Tables 1–3, a fur-

ther limitation of Naturalowl’s content selection isthat it only retrieves information that is explicit inthe domain ontology. It cannot deduce additional in-formation about the target from other statementsin the domain ontology; see Mellish et al. [122] formechanisms to deduce facts in content selection.

16 In Naturalowl, canned texts can also be entered as natural

language names (see Section 2.2.1) of pseudo-individuals; thepseudo-individuals can then be used instead of the cannedtexts in the domain ontology, provided that the correspond-

ing string-valued properties are converted to object proper-ties. This way, canned texts can be entered (in the domain-

dependent generation resources) in multiple versions (for dif-

ferent languages and user types) as different versions of thenatural language names of the pseudo-individuals, without

cluttering up the domain ontology with multiple strings.

9

We also note that owl allows one to define thebroadest possible domain and range of a particularproperty, using statements like the following.

ObjectPropertyDomain(:madeFromGrape :Wine)

ObjectPropertyRange(:madeFromGrape :Grape)

In practice, more specific range restrictions are thenimposed for particular subclasses of the domain. Forexample, the following statements specify that whenmadeFromGrape is used with individuals from the sub-class GreekWine of Wine, the range (possible values)of madeFromGrape should be restricted to individualsfrom the subclass GreekGrape of Grape.

SubClassOf(:GreekWine :Wine)

SubClassOf(:GreekGrape :Grape)

SubClassOf(:GreekWine

AllValuesFrom(:madeFromGrape :GreekGrape))

Naturalowl considers AllValuesFrom and similar re-strictions, but it ignores ObjectPropertyDomain andObjectPropertyRange statements. 17 Considering thelatter statements as well would be easy, but theytypically provide too general and, hence, uninterest-ing information from the perspective of end-users.

More generally, Naturalowl does not considerowl statements that express axioms about proper-ties, meaning statements declaring that a propertyis symmetric, asymmetric, reflexive, irreflexive,transitive, functional, that its inverse is functional,that a property is the inverse of, or disjoint withanother property, that it is subsumed by a chain ofother properties, or that it is a subproperty (morespecific) of another property. Statements of thiskind are mostly useful in consistency checks, in de-duction, or when generating texts describing theproperties themselves (e.g., what being a grandpar-ent of somebody means), cases that are not directlyrelevant to the work of this article. 18

Converting candidate facts to message triplesTables 4 and 5 list more exhaustively all the forms

of candidate facts that are considered when describ-ing a target individual or class, i.e., all the candidatefacts that are admitted by Tables 1–3. Tables 4 and5 also show how the candidate facts can be rewrit-ten as triples of the form 〈S, P,O〉, where S is alwaysthe target or a second-level target; O is an individ-ual, a datatype value, a class, or a set of individuals,

17The only exception is when it expresses cardinality restric-tions; see Table 7 of Section 2.2.1 below.18Subproperties without sentence plans, discussed below,

could inherit sentence plans from their super-properties, butin that case we automatically extract sentence plans from

the domain ontology instead.

:exhibit24

:Aryballos

:heraionOfDelos

:blackFigureTechnique

:archaicPeriod

:delosMuseum

:Vase

“An aryballos was a…”

“700 to 480 BC”

“The archaic period was when…”

instanceOf

isA

:paintingTechniqueUsed

:locationFound

:currentMuseum

:exhibitTypeCannedDescription

:creationPeriod

:periodDuration :periodCanned

Description

Figure 2. Graph view of message triples corresponding to

candidate facts. The target is the individual exhibit24.

datatype values, or classes that S is mapped to; Pspecifies the kind of mapping. We call S the seman-tic subject or owner of the triple, and O the seman-tic object or filler ; the triple can also be viewed as afield named P , owned by S, and filled by O. For ex-ample, the candidate facts about exhibit24 on page8, including the additional facts about the second-level targets, are converted to the following triples.

<:exhibit24, instanceOf, :Aryballos>

<:exhibit24, :locationFound, :heraionOfDelos>

<:exhibit24, :creationPeriod, :archaicPeriod>

<:exhibit24, :paintingTechniqueUsed,

:blackFigureTechnique>

<:exhibit24, :currentMuseum, :delosMuseum>

<:Aryballos, isA, :Vase>

<:Aryballos, :exhibitTypeCannedDescription,

"An aryballos was a small spherical vase with a

narrow neck, in which the athletes kept the oil

they spread their bodies with"^^xsd:string>

<:archaicPeriod, :periodDuration,

"700 BC to 480 BC"^^xsd:string>

<:archaicPeriod, :periodCannedDescription,

"The archaic period was when the Greek ancient

city-states developed"^^xsd:string>

<:blackFigureTechnique,

:techniqueCannedDescription,

"In the black-figure technique, the silhouetes

are rendered in black on the pale surface of the

clay, and details are engraved"^^xsd:string>

More precisely, P can be: (i) a property of the do-main ontology; (ii) one of the keywords instanceOf,oneOf, differentIndividuals, sameIndividuals, isA; or(iii) an expression of the form modifier(ρ), wheremodifier may be not, maxCardinality etc. (see Tables4 and 5) and ρ is a property of the domain ontol-ogy. We hereafter call properties all three types of P ,though types (ii) and (iii) are strictly not propertiesin owl’s terminology. When we need to distinguishbetween the three types, we use the terms propertyof the domain ontology, domain-independent prop-erty, and modified property, respectively.

For readers familiar with rdf, we note that the

10

candidate facts (for an individual target) as owl statements candidate facts as message triples

ClassAssertion(NamedClass target ) <target, instanceOf, NamedClass >

ClassAssertion(ObjectComplementOf(NamedClass ) target ) <target, not(instanceOf), NamedClass >

ClassAssertion(ObjectOneOf(indiv1 indiv2 ...) target ) <target, oneOf, or(indiv1, indiv2, ...)>

ClassAssertion(ObjectHasValue(objProp indiv ) target ) <target, objProp, indiv >

ClassAssertion(ObjectHasValue(dataProp dataValue ) target ) <target, dataProp, dataValue >

ClassAssertion(ObjectHasSelf(objProp ) target ) <target, objProp, target >

ClassAssertion(

ObjectMaxCardinality(number prop [NamedClass ]) target )

<target, maxCardinality(prop ),

number [:NamedClass ]>

ClassAssertion(

ObjectMinCardinality(number prop [NamedClass ]) target )

<target, minCardinality(prop ),


ClassAssertion(

ObjectExactCardinality(number prop [NamedClass ]) target )

<target, exactCardinality(prop ),


ClassAssertion(

ObjectSomeValuesFrom(objProp NamedClass ) target )

<target, someValuesFrom(objProp ),

NamedClass >

ClassAssertion(

ObjectAllValuesFrom(objProp NamedClass ) target )

<target, allValuesFrom(objProp ),

NamedClass >

ClassAssertion(ObjectIntersectionOf(C1 C2 ...) target ) convert (ClassAssertion(C1 target ))

convert (ClassAssertion(C2 target )) . . .

ClassAssertion(ObjectUnionOf(C1 C2 ...) target ) or(convert (ClassAssertion(C1 target )),

convert (ClassAssertion(C2 target )), ...)

ObjectPropertyAssertion(objProp target indiv ) <target, objProp, indiv >

DataPropertyAssertion(dataProp target dataValue ) <target, dataProp, dataValue >

DifferentIndividuals(target indiv ) <target, differentIndividuals, indiv >

DifferentIndividuals(indiv target ) <target, differentIndividuals, indiv >

SameIndividual(target indiv ) <target, sameIndividual, indiv >

SameIndividual(indiv target ) <target, sameIndividual, indiv >

Table 4Candidate facts when generating a text for an individual (see also Tables 1 and 2), and how they can be converted to message

triples. Square brackets indicate optional arguments, and convert (ξ) denotes a recursive application of the conversion to ξ.

triples of Tables 4 and 5 are not exactly rdf triples.Most notably, expressions of the form modifier(ρ)cannot be used as P in rdf triples. Overall, eachtriple produced by Tables 4 and 5 is intended tobe easily expressible as a single sentence, which isnot always the case with rdf triples representingowl statements. To avoid confusion, we use theterm message triples to refer to the triples that Ta-bles 4 and 5 generate, as opposed to rdf triples. 19

As with rdf triples, message triples can be viewedas a graph, which is very similar to ilex’s con-

19Message triples correspond to Reiter and Dale’s [145] mes-

sages. Message triples can be converted to rdf triples.

tent potential [132]. Figure 2 shows a graph for themessage triples of exhibit24; to save space, we ex-clude the triple that links blackFigureTechnique to acanned sentence. The second-level targets are thenodes of classes and individuals at distance one fromexhibit24. The graph for the rdf triples would bemore complex, and second-level targets would notalways be at distance one from the current target.

Notice that Table 5 converts EquivalentClasses andSubClassOf statements to identical triples, where P isisA, since Naturalowl produces the same texts fromboth kinds of statements, as already discussed. As afurther example, owl statements like the followingtwo are mapped to identical message triples, apart

11

candidate fact (for a class target) as owl statements candidate facts as message triples

EquivalentClasses(Target Class ) convert (SubClassOf(Target Class ))

EquivalentClasses(Class Target ) convert (SubClassOf(Target Class ))

SubClassOf(Target NamedClass ) <Target, isA, NamedClass >

SubClassOf(Target ObjectComplementOf(NamedClass )) <Target, not(isA), NamedClass >

SubClassOf(Target ObjectOneOf(indiv1 indiv2 ...)) <Target, oneOf, or(indiv1, indiv2, ...)>

SubClassOf(Target ObjectHasValue(objProp indiv )) <Target, objProp, indiv >

SubClassOf(Target ObjectHasValue(dataProp dataValue )) <Target, dataProp, dataValue >

SubClassOf(Target ObjectHasSelf(objProp )) <Target, objProp, Target >

SubClassOf(Target

ObjectMaxCardinality(number prop [NamedClass ]))

<Target, maxCardinality(prop ),


SubClassOf(Target

ObjectMinCardinality(number prop [NamedClass ]))

<Target, minCardinality(prop ),


SubClassOf(Target

ObjectExactCardinality(number prop [NamedClass ]))

<Target, exactCardinality(objProp ),


SubClassOf(Target

ObjectSomeValuesFrom(objProp NamedClass ))

<Target, someValuesFrom(objProp ),

NamedClass >

SubClassOf(Target

ObjectAllValuesFrom(objProp NamedClass ))

<Target, allValuesFrom(objProp ),

NamedClass >

SubClassOf(Target ObjectIntersectionOf(C1 C2 ...)) convert (SubClassOf(C1 Target ))

convert (SubClassOf(C2 Target )) . . .

SubClassOf(Target ObjectUnionOf(C1 C2 ...)) or(convert (SubClassOf(C1 Target )),

convert (SubClassOf(C2 Target )), ...)

DisjointClasses(Target NamedClass ) <Target, not(isA), NamedClass >

DisjointClasses(NamedClass Target ) <Target, not(isA), NamedClass >

Table 5

Candidate facts when generating a text for a class (see also Tables 2 and 3), and how they can be converted to messagetriples. Square brackets indicate optional arguments, and convert (ξ) denotes a recursive application of the conversion to ξ.

from the identifiers of the individual and the class.

ClassAssertion(

ObjectMaxCardinality(1 :madeFromGrape)

:product145)

SubClassOf(:StEmilion

ObjectMaxCardinality(1 :madeFromGrape))

The resulting message triples, shown below, are in-tended to reflect the similarity of the correspondingsentences that Naturalowl would generate.

<:product145, maxCardinality(:madeFromGrape), 1>

Product 145 is made from at most one grape.

<:StEmilion, maxCardinality(:madeFromGrape), 1>

St. Emilion is made from at most one grape.

Tables 4 and 5 also discard ObjectIntersectionOf op-

erators, producing multiple message triples instead.For example, the SubClassOf for StEmilion on page 8would be converted to the following triples.

<:StEmilion, isA, :Bordeaux>

<:StEmilion, :locatedIn, :stEmilionRegion>

<:StEmilion, :hasColor, :red>

<:StEmilion, :hasFlavor, :strong>

<:StEmilion, :madeFromGrape,

:cabernetSauvignonGrape>

<:StEmilion, maxCardinality(:madeFromGrape), 1>

The triples correspond to the sentences below,where subsequent references to StEmilion have beenreplaced by pronouns. The sentences could be ag-gregated into longer ones as discussed below.

St. Emilion is a kind of Bordeaux. It is from the St.

Emilion region. It has red color. It has strong flavor. It

12

is made from Cabernet Sauvignon grape. It is made from

at most one grape variety.

Tables 4 and 5 also replace ObjectUnionOf operatorsby disjunctions of message triples. The assertion:

ClassAssertion(

UnionOf(


ObjectHasValue(:hasFlavor :medium))

:houseWine)

becomes:

or(<:houseWine, :hasFlavor, :strong>,

<:houseWine, :hasFlavor, :medium>)

which corresponds to the following setence.

The house wine has strong flavor or it has medium flavor.

The need for interest scoresConveying to an end-user all the message triples

of all the candidate facts is not always appropriate.Let us assume, for example, that the maximum factdistance is 2 and that a description of exhibit24 ofFigure 2 has been requested by a museum visitor.It may be the case that the visitor has already en-countered other exhibits of the archaic period, andthat the duration of that period was mentioned inthe previous descriptions. Repeating the archaic pe-riod’s duration may, thus, be undesirable. We mayalso want to exclude candidate facts that are unin-teresting to particular types of users. For example,there may be message triples providing bibliographicreferences; archaeologists may find them interesting,but children would probably not. Therefore, mecha-nisms are needed to determine which candidate mes-sage triples should be conveyed to each user.

Following ilex and m-piro, each message tripleis assigned an interest score, possibly different peruser type. The score is a non-negative integer indi-cating how interesting a user of the correspondingtype will presumably find the triple’s information,if the information has not already been conveyed tothe user. 20 Furthermore, personal user models, tobe discussed, keep track of the message triples thesystem has expressed to each particular user.

In the museum projects Naturalowl was origi-nally developed for, the interest scores ranged from0 (completely uninteresting) to 3 (very interesting);a different maximum score can also be used. Thescores were set by consulting museum curators,

20 ilex distinguishes between interest and importance, thelatter being the educational value of each fact, which may be

different from its interest [132]. We use only interest scores.

who were shown a list of all the properties of thedomain ontology (e.g., locationFound) that appliedto targets (exhibits) or second-level targets (e.g.,historical periods), along with sample sentencesexpressing message triples involving each property.The curators were asked to specify how interestingthe information expressed by each property wouldgenerally be per user type. 21 Each message triplewas then assigned the interest score of its prop-erty. The user types (e.g., non-expert adult, expertadult, child) were also suggested by the curators.The curators later examined the generated textsand suggested further refinements of the interestscore assignments, which would occasionally applyto 〈S, P,O〉 message triples with a particular in-dividual or class as their S, rather than to all themessages triples that involved a particular propertyP . Hence, we had to allow refinements of this kind.

We note that when large numbers of human-authored texts describing individuals and classesof the domain ontology are available, along withthe corresponding logical facts expressed by eachtext, statistical and machine learning methods canbe employed to learn to automatically select orassign interest scores to logical facts (or messagetriples) [52,10,91,93,5]. Another possibility wouldbe to compute the interest scores with centralityalgorithms. Algorithms of this kind assign higher orlower importance to a graph’s nodes by consideringhow well connected they are and how importanttheir neighbors are. Demir et al. [45], for example,applied a version of PageRank [29] to a graph thathad nodes standing for candidate logical facts, andedges corresponding to relations between facts (e.g.,showing that two facts share individuals, or thatthey should or should not be selected together).

Let us now explain how message triples 〈S, P,O〉are (manually) assigned interest scores in Natu-ralowl. Three types of annotations of the domainontology can be used; we discuss them in turn.

Assigning interest scores by specifying P onlyAn annotation of this type applies to all the mes-

sage triples involving a particular P , regardless of Sand O. For example, let us assume that any triplewhose P is currentMuseum, like the one below, shouldhave an interest score of 1 when generating texts forchildren; by contrast, the interest score should be 3when generating texts for experts.

21Consult Reiter et al. [146] for a discussion of knowledge

acquisition methods that can be used in nlg.

13

_:node1

dgr:child

nlowl:forUserType

:currentMuseum

nlowl:forProperty

1 nlowl:AnnotationEvent

instanceOf nlowl:hasInterest

nlowl:UserType

instanceOf

_:node2

dgr:expert

nlowl:forUserType nlowl:forProperty

3

instanceOf

instanceOf nlowl:hasInterest

Figure 3. Graph view of annotations providing interestscores. Message triples involving the currentMuseum property

are assigned an interest of 1 for children and 3 for experts.

<:exhibit24, :currentMuseum, :delosMuseum>

The following annotations can be used. The annota-tions themselves are also owl statements, and Fig-ure 3 shows them as a graph.

AnnotationAssertion(nlowl:forProperty

_:node1 :currentMuseum)

ObjectPropertyAssertion(nlowl:forUserType

_:node1 dgr:child)

ObjectPropertyAssertion(nlowl:hasInterest

_:node1 "1"^^xsd:nonNegativeInteger)




_:node2 dgr:expert)



Intuitively, the statements above introduce two an-notation events. The first one (node1) concerns chil-dren and annotates the property currentMuseum withan interest score of 1. The second event (node2) con-cerns experts and annotates the same property withan interest score of 3. If the forUserType of an an-notation event is left unspecified, the interest scoreapplies to all the user types.

For simplicity, we use the default namespace(a colon without a prefix) with properties (e.g.,:currentMuseum), classes etc. of the domain ontology.The nlowl namespace prefix is used with domain-independent properties, classes etc. that are definedin Naturalowl’s generation resources ontology(e.g., nlowl:forProperty); and the dgr prefix is usedwith domain-dependent instances (e.g., individu-als) of Naturalowl’s generation resources ontology.The user types child and expert in the exampleabove would be declared to be individuals of theclass UserType (as shown below), which is defined inNaturalowl’s generation resources ontology.

ClassAssertion(dgr:child nlowl:UserType)

ClassAssertion(dgr:expert nlowl:UserType)

Since we may wish to use different user types withdifferent domain ontologies, child and expert are

considered domain-dependent, which is why theyhave the dgr prefix. 22 Individuals whose prefixesare underscores (e.g., :node1, :node2) are consideredanonymous in owl; strictly speaking, they shouldbe shown as nodes without labels in the graphs.

Statements of the form AnnotationAssertion(anProp

element value ) are used in owl to map any element

(e.g., class, property, individual) of an ontology toany value (e.g., individual, datatype value) via anannotation property anProp in order to express meta-information that is not considered part of the on-tology’s conceptualization. For example, annotationproperties are commonly used to associate elementswith comments. We use annotation properties whenlinking elements of the domain ontology to elementsof the generation resources ontology, or vice versa,but we use ordinary properties when linking (inter-nally) elements of the domain ontology or when link-ing (internally) elements of the generation resourcesontology. The AnnotationAssertion statements thatwe use can be thought of as annotations of the do-main ontology that associate it with linguistic anduser modeling resources, which are not part of thedomain ontology’s conceptual model. 23 Like objectand datatype properties, annotation properties canexpress directly only binary relations. Hence, we fol-low common practice and use anonymous individ-uals (e.g., :node1) that stand for reified events toexpress relations of more than two arguments.

Recall that the P of a message triple 〈S, P,O〉 isnot always a property of the domain ontology (seeTables 4 and 5). It may be a modified property,like maxCardinality(currentMuseum), in which case wesay that maxCardinality is a modifier of currentMuseum.The statements below specify that message tripleswhose P is exactCardinality(currentMuseum) have aninterest score of zero when interacting with children;users are never told zero interest facts.



ObjectPropertyAssertion(nlowl:forModifier

_:node3 nlowl:exactCardinality)


_:node3 dgr:child)

22 In practice, dgr would be an abbreviation of a namespaceother than that of the domain ontology and Naturalowl’s

generation resources ontology, to avoid name clashes. Acomplete definition (in owl) of Naturalowl’s generation re-sources ontology is included in the system’s software.23Annotation properties have the additional advantage that

they can map classes or properties, not just individuals, tovalues, and the values themselves can also be properties; this

turns out to be useful in some of Naturalowl’s annotations.

14



By omitting the forProperty, we can also specify,for example, that triples with an exactCardinality

should never be expressed to children, regardlessof the property the modifier applies to. Whenthere are conflicting interest scores (e.g., forexactCardinality(currentMuseum) and exactCardinality

in general), the most specific one prevails. 24

In practice, the user modeling annotations are en-tered by using Naturalowl’s Protege plug-in, in-stead of writing owl statements. The annotationevents are automatically generated by the plug-in,and they are not shown to the domain author.

Assigning interest scores by specifying both S and PMost message triples 〈S, P,O〉 are assigned inter-

est scores by using annotations that specify a par-ticular P (and/or possibly a modifier), an interestscore, and possibly a particular user type, as dis-cussed above. In some cases, however, we may alsowant the annotations to specify a particular S. Forexample, we may have assigned, say for all usertypes, an interest score of 3 to message triples whoseP is instanceOf, i.e., triples expressing the class of S.In the following triple, however, we would probablywant to set the interest score to zero, because thenatural language name of S makes it obvious that Sis a museum, i.e., we would want to avoid generatingthe corresponding sentence.

<:delosMuseum, instanceOf, :Museum>

The Museum of Delos is a museum.

This is achieved below by specifying that messagetriples whose P is instanceOf and S is delosMuseum

have zero interest for all user types; recall that S isalso called the owner of the triple.


_:node4 nlowl:instanceOf)

AnnotationAssertion(nlowl:forOwner

_:node4 :delosMuseum)



Similarly, we may wish to specify that the materi-als of a museum’s exhibits are generally of mediuminterest (score 2), that the materials of statues areof lower interest (score 1), perhaps because they areall made from stone, but that the material of a par-ticular statue, exhibit10, is very important (score 3),

24 In the case of disjunctions of message triples, the entiredisjunction is assigned the average of the interest scores of its

triples, and the disjunction is expressed as a single sentence.

perhaps because it is gold. We could use the follow-ing statements. The first annotation event (node5) isoverriden by the second one (node6), when S is theclass Statue or any individual that belongs in thatclass. The third annotation event (node7) overridesboth of the previous ones, when S is exhibit10.


_:node5 :hasMaterials)






_:node6 :Statue)






_:node7 :exhibit10)



There should perhaps also be a mechanism to assigninterest scores by specifying P andO, for example toassign a high interest to triples indicating that some(any) exhibit is made of gold. Naturalowl, however,currently provides no such mechanism.

Assigning interest scores at the global levelMessage triples may also be assigned interest

scores by using global annotations specifying nei-ther P nor S; the annotations then apply to all themessage triples. For example, the following state-ment assigns an interest score of 1 to all triples,unless otherwise specified; this is also the default.



A forUserType can be used to restrict the scope of aglobal annotation to a particular user type.

Repetitions and personal user modelsFollowing ilex and m-piro, Naturalowl’s user

modeling annotations also specify how many timeseach message triple has to be repeated in the gen-erated texts, before it can be assumed that users ofdifferent types have assimilated it. Once a triple hasbeen assimilated, it is never repeated in texts for thesame user, unless the user’s personal model is re-set. For example, the annotations may indicate thatfor children, the duration of a historical period isassimilated only after it has been mentioned twice;hence, the system may repeat the duration of the

15

archaic period in two texts about exhibits of thatperiod. The necessary repetitions are specified muchas when specifying interest scores. For example, thefollowing statements set both the interest score (to1) and the required repetitions (to 2) for childrenat the global level, i.e., for all properties, using asingle annotation event. If not specified otherwise,message triples are expressed only once.


_:node9 dgr:child)



ObjectPropertyAssertion(nlowl:maxRepetitions


A maxRepetitions score of 0 signals that the tripleshould never be considered assimilated.

Naturalowl maintains a personal model for eachend-user. The model shows which message tripleswere conveyed to that user in previous texts, andhow many times. Each end-user is assigned a uniqueidentifier during a login phase, and the identifiers areused to retrieve their personal models. During thelogin phase, the users also select their types; in oneof m-piro’s demonstrators, for example, the usertypes were depicted using cartoon characters, andthe users selected the character they felt closer to.

Selecting the message triples to conveyWhen asked to describe a target, Naturalowl first

retrieves from the domain ontology the candidatefacts up to the maximum fact distance. It then con-verts the candidate facts to message triples, and itemploys the user modeling annotations and the per-sonal user models to rank the triples by decreasinginterest score, discarding triples that have alreadybeen assimilated. If a message triple at distanceone has been assimilated, then all the distance twotriples that are connected to the assimilated tripleare also discarded; for example, if the creationPeriod

triple (edge) of Figure 2 has been assimilated, thenthe triples about the archaic period (the edges leav-ing from archaicPeriod) are also discarded. The sys-tem then selects up to maxMessagesPerPage triples fromthe most interesting remaining ones. The value ofmaxMessagesPerPage can be set to smaller or larger val-ues for types of users that prefer shorter or longertexts. The following statement indicates that eachtext should express at most 10 message triples wheninteracting with children. The default is to conveyall the non-assimilated candidate message triples.

DataPropertyAssertion(nlowl:maxMessagesPerPage

dgr:child "10"^^xsd:nonNegativeInteger)

In some applications, it may be possible to allowusers to specify their personal maxMessagesPerPage

value, for example via a slide-bar, but a reasonableinitial value per user type is desirable in most cases.

2.1.2. Text planningFor each target class or individual, the mecha-

nisms of the previous section produce the messagetriples to be expressed, with each triple intendedto be easily expressible as a single sentence. Natu-ralowl’s text planning stage then orders the mes-sage triples, in effect ordering the sentences of theresulting text. We discuss the functionality and re-sources of this stage, after first providing some back-ground on text planning, for the benefit of readersunfamiliar with nlg and also to explain why someparticular methods were chosen in Naturalowl.

Related work on global coherenceAmong other considerations, text planners often

aim to maximize the global or local coherence of theresulting texts, or both. When considering global co-herence, they attempt to build a structure, usually atree, that shows how the clauses, sentences, or largersegments (or their meaning representations, in ourcase the message triples) are related to each other,often in terms of rhetorical relations, as in Rhetor-ical Structure Theory (rst) [113]. For example, asentence or other segment may justify, elaborate, orcontradict another one, it may provide backgroundinformation etc. The allowed or preferred orderingsof the text’s sentences (or segments) often follow, atleast partially, from its global coherence structure.

In the texts, however, that Naturalowl is in-tended to generate, i.e., factual descriptions of in-dividuals or classes, the global coherence structurestend to be rather uninteresting, because most ofthe sentences simply provide additional informationabout the target or the second-level targets; thesentences are connected mostly via what are usuallycalled ‘elaboration’, ‘list’, or ‘background’ relations.Hence, global coherence structures are not particu-larly informative in our case, which is why they arenot used in Naturalowl. Consult, for example, Hovy[80], Moore and Paris [128], and Paris et al. [134] fordescriptions of systems that use global coherencestructures, rhetorical relations, and plan libraries.Mellish et al. [120] employ genetic algorithms tosearch for a good global coherence structure, givena set of facts to convey (per text) and a set of possi-ble rhetorical relations that connect them. Duboueand McKeown [51] also use genetic algorithms, but

16

to learn a single text planner (for all the texts to begenerated), given a training set of semantic inputsand the corresponding human-authored texts.

We note that Liang et al. [109] discuss using rst inan ontology verbalizer; they seem to agree, however,that very few types of rst relations are relevantwhen generating texts from owl ontologies. Also,Power [138] studied when two sentences expressingClassAssertion, SubClassOf, or ObjectPropertyAssertion

axioms are judged by humans to be rhetorically re-lated; and when they are, what kinds of rhetori-cal relations they express, and how the relationsare expressed (e.g., by using discourse connectivesor sentence aggregation). Power found 11 patternsof rhetorically related pairs of sentences (and ax-ioms). Most of these patterns, however, do not applyto the sentences that Naturalowl produces; for ex-ample, many patterns express contrast or compar-isons between two target classes, whereas in Natu-ralowl there is always only one target. Only twoof Power’s patterns seem to apply to Naturalowl’ssentences: additive elaboration (e.g., “Dogs are ca-nines; dogs are domestic mammals”) and forwardreasoning (e.g., “Dogs are canines; canines are ver-tebrates”). 25 Additive elaboration is handled rea-sonably well by Naturalowl’s sentence aggregationrules, discussed below. Forward reasoning sentencesare placed next to each other by Naturalowl’s textplanner; no discourse connective is used, but Power’sdata suggest that humans also rarely use discourseconnectives in this case.

Local coherenceWhen considering local coherence, text planners

usually aim to maximize measures that examine,roughly speaking, whether or not adjacent sentences(or other segments) continue to focus on (i.e., talkprimarily about) the same entities or, if the focuschanges, how smooth the transition is. Many localcoherence measures are based on Centering Theory(ct) [66,170,135], which we briefly discuss first. 26

25Widening elaboration and narrowing elaboration pairs

[138] may also, in principle, be generated by Naturalowl,but they seem to be rare in practice, because they occurwhen the domain ontology contains redundant statements,for example explicitly stating that dogs are both canines and

vertebrates, and also that canines are vertebrates.26Consult Karamanis et al. [87] for a summary of measures

based on ct. Readers unfamiliar with ct should still be ableto follow most of the discussion here. For those who wishto grasp the full details, the article of Karamanis et al. also

serves as a concise introduction to relevant ct concepts.

In ct, each utterance un (in our case, sentence)is associated with a set of forward-looking centers ofattention, denoted Cf (un). The members of Cf (un)are discourse entities realized as noun phrases in un;in our case, the discourse entities are individualsor classes of the domain ontology. The members ofCf (un) can be ordered by their salience, which re-flects the salience of the noun phrases that realizethem in un; for example, subject noun phrases areconsidered more salient than object noun phrases.The most salient member of Cf (un) is un’s preferredcenter, denoted cp(un). In a sentence that Natu-ralowl generates for a message triple 〈S, P,O〉, typ-ically Cf (un) = {S,O} and cp(un) = S, since S istypically realized as the subject of un. 27

Let un−1 be the utterance (sentence) immediatelybefore un. The most salient member of Cf (un−1)that is also realized in un is the backward-lookingcenter of un, denoted cb(un). If no member ofCf (un−1) is realized (repeated) in un, then cb(un)is undefined and we have a type of transition fromun−1 to un that Karamanis et al. [87] and others callnocb, a transition type to be avoided. The preferredtype of sentence-to-sentence transition, continue,occurs when cp(un) = cb(un) = cb(un−1). If un−1

is the first utterance of the text, cb(un−1) is unde-fined. However, if cb(un−1) is undefined but cb(un)exists, cb(un) = cb(un−1) is taken to hold; a nocboccurs (from un−1 to un) when cb(un) is undefined.

When Naturalowl’s maximum fact distance isone, all the transitions in the generated texts arecontinue, because cp(un) = cb(un) = cb(un−1) =t, for every un with n > 1, where t is the target, i.e.,the individual or class described by the text. To il-lustrate this, we repeat the short description of thearyballos of page 8, without aggregating sentences.

This (exhibit) is an aryballos. It was found at the Heraion

of Delos. It was created during the archaic period. It was

decorated with the black-figure technique. It is currently

in the Museum of Delos.

The subjects of all the sentences, shown in italics,realize t, and cp(un) = t in every utterance. Weshow underlined the noun phrase of each sentencethat realizes its cb(un). In our example, for everyn > 1, cb(un) is the discourse entity realized by the

27We say typically, because there is actually nothing to pre-vent a domain author from providing an unusual sentence

plan that, for example, causes Naturalowl to realize S as the

object of the sentence; sentence plans are discussed below.Also, when canned texts are used, cp(un) may occasionally

not be realized as the subject; we provide an example below.

17

subject of un−1, i.e., t; hence, cp(un) = cb(un) = t.Furthermore, for every n > 2, cb(un) = cb(un−1) =t; and for n = 2, cb(un−1) is undefined and cb(un) =t, hence cb(un) = cb(un−1) is taken to hold.

If the maximum fact distance is two, however, thetransitions are not always continue. 28 In our ex-ample, the description of the aryballos becomes asfollows. We now repeat the long description of page9, again without sentence aggregation. The mostsalient noun phrase of each sentence, which realizescp(un), is shown in italics. In the (canned) ninth sen-tence, the most salient noun phrase is the one insidethe sentence-initial prepositional phrase; in all theother sentences, it is the subject. Again, the under-lined noun phrases realize cb(un).

(1) This (exhibit) is an aryballos. (2) An aryballos is a

kind of vase. (3) An aryballos was a small spherical vase

with a narrow neck, in which the athletes kept the oil

they spread their bodies with. • (4) This particular ary-

ballos was found at the Heraion of Delos. (5) It was cre-

ated during the archaic period. (6) The archaic period

was when the Greek ancient city-states developed. (7)

It spans from 700 bc to 480 bc. • (8) This aryballos

was decorated with the black-figure technique. (9) In

the black-figure technique, the silhouetes are rendered in

black on the pale surface of the clay, and details are en-

graved. • (10) This aryballos is currently in the Museum

of Delos.

In the second sentence above, cp(u2) is the class ofaryballoi (plural of aryballos), not the particular tar-get exhibit t the text is generated for; cb(u2) is alsothe aryballos class; cb(u1) is undefined, but cb(u2) =cb(u1) is taken to hold. Hence, the transition from u1to u2 is a continue. In sentence 3, cp(u3) is againthe class of aryballoi, and cp(u3) = cb(u3) = cb(u2),i.e., the transition is again a continue. In sentence4, however, where cp(u4) is the particular target ex-hibit t, no forward-looking center of the previoussentence is mentioned and, hence, cb(u4) is unde-fined and the transition from sentence 3 to sentence4 is a nocb; we mark nocb transitions with bul-lets. 29 In sentence 5, cp(u5) = t = cb(u5) and cb(u4)is undefined; hence, the transition from sentence 4to 5 is a continue. In sentence 6, cp(u6) is the ar-chaic period, which is also cb(u6), but cb(u5) is the

28See also the analysis of m-piro’s generated texts by Kara-manis et al. [87].29 It could be argued that the transition from (3) to (4)

involves a kind of bridging relation [35] from the whole classto one of its individuals, which smoothens the transition;

Kibble and Power [92] make a similar observation.

exhibit t; hence, cp(u6) = cb(u6) 6= cb(u5), and wehave a kind of transition known as smooth-shift,which is less preferred than continue, but betterthan nocb. A continue then occurs in sentence 7,a nocb in sentence 8, followed by a smooth-shiftin sentence 9, and another nocb in sentence 10.

Naturalowl’s text planning algorithm, discussedbelow, always groups together sentences (more pre-cisely, message triples) that describe a particularsecond-level target (e.g., sentences 2–3, 6–7, and 9)and it places each group immediately after the sen-tence that introduces the corresponding second-leveltarget (immediately after sentences 1, 5, and 8, re-spectively). Thus the transition from a sentence thatintroduces a second-level target to the first sentencethat describes the second-level target (e.g., from sen-tence 1 to 2, from 5 to 6, from 8 to 9) is a smooth-shift (or a continue in the special case from theinitial sentence 1 to 2). 30 A nocb occurs only at sen-tences that return to providing information aboutthe primary target, after a group of sentences thatprovide information about a second-level target. Allthe other transitions are of type continue.

The resulting number of nocbs equals the num-ber of second-level targets described by at least amessage triple, minus one if the last message triple(sentence) is not about the primary target. This isthe smallest possible number of nocbs for any re-ordering of the message triples, excluding special(and in practice rare) cases where a second-levelmessage triple connects a second-level target backto the primary target, allowing a sentence about theprimary target to follow without a nocb. 31 Kara-manis et al. [87] provide experimental evidence frommultiple text genres showing that simply minimizingnocb transitions leads to sentence orderings thatpeople find better or as good as orderings that min-imize several other, more elaborate ct-based localcoherence measures. Hence, the oderings that Natu-ralowl produces, which minimize nocbs, are com-petitive to orderings produced by minimizing other

30The transition between sentences 1 and 2 should per-haps also be considered a smooth-shift. retain transitions,

where cp(un) 6= cb(un) = cb(un−1), and rough-shift tran-

sitions, where cp(un) 6= cb(un) and cb(un) 6= cb(un−1), donot occur in the sentences that Naturalowl typically gener-

ates, unless nocb is viewed as a rough-shift.31We can sometimes reduce the nocbs by one, by placinglast, if possible, a sentence describing a second-level target.For example, moving sentence (10) immediately after (4)

saves the nocb transition from (9) to (10). Naturalowl doesnot perform this check and, hence, the number of nocbs

may exceed the minimum by one, but we ignore this detail.

18

ct-based local coherence measures. Also, when us-ing other local coherence measures, the optimum or-dering may not be obvious; and searching for theordering that maximizes the sum of the sentence-to-sentence local coherence scores is np-complete [9,1].

A simple strategy to avoid nocb transitions wouldbe to end the generated text once all the messagetriples that describe a second-level target have beenreported, and record in the user model that the othermessage triples that content selection had providedwere not actually conveyed. In our example, thiswould generate sentences 1 to 3; then if the userrequested more information about the exhibit, sen-tences 4 to 7 would be generated, and so on.

Topical orderWhen ordering sentences, we also need to consider

the topical similarity of adjacent sentences. Com-pare, for example, the following two texts.

{locationSection The Stoa of Zeus Eleutherios is located

in the western part of the Agora. It is located next to

the Temple of Apollo Patroos.} {buildSection It was built

around 430 bc. It was built in the Doric style. It was built

out of porous stone and marble.} {useSection It was used

during the Classical period, the Hellenistic period, and

the Roman period. It was used as a religious place and a

meeting point.} {conditionSection It was destroyed in the

late Roman period. It was excavated in 1891 and 1931.

Today it is in good condition.}

The Stoa of Zeus Eleutherios was built in the Doric style.

It was excavated in 1891 and 1931. It was built out of

porous stone and marble. It is located in the western part

of the Agora. It was destroyed in the late Roman period.

It was used as a religious place and a meeting point. It

is located next to the Temple of Apollo Patroos. It was

built around 430 bc. Today it is in good condition. It was

used during the Classical period, the Hellenistic period,

and the Roman period.

Both texts express the same message triples, shownbelow. Notice that we use a single hasMaterial mes-sage triple, whose filler is an and(...), instead of twodifferent triples (one for each material), and simi-larly for usedDuringPeriod. This kind of triple mergingis in effect a form of aggregation, discussed below,but it takes place during content selection.

<:stoaZeusEleutherios, :isInArea, :westAgora>

<:stoaZeusEleutherios, :isNextTo,

:templeApolloPatroos>

<:stoaZeusEleutherios, :hasApproxConstructYearBC,

"430"^^xsd:nonNegativeInteger>

<:stoaZeusEleutherios, :hasStyle, :doricStyle>

<:stoaZeusEleutherios, :hasMaterial,

and(:porousStone, :marble)>

<:stoaZeusEleutherios, :usedDuringPeriod,

and(:classicalPeriod, :hellenisticPeriod,

:romanPeriod)>

<:stoaZeusEleutherios, :usedAs,

"a religious place and a meeting point"^^xsd:string>

<:stoaZeusEleutherios, :hasDestructionTime},

"in the late Roman period"^^xsd:string>

<:stoaZeusEleutherios, :hasExcavationYearAD,


<:stoaZeusEleutherios, :hasExcavationYearAD,


<:stoaZeusEleutherios, :isInCurrentCondition,

:goodCondition>

We listed the message triples with the order of thecorresponding sentences in the first text, but at thebeginning of text planning the triples are actuallyunordered. Even though both texts express the samemessage triples and contain the same sentences, thesecond text is more difficult to follow, if at all accept-able. The first one is better, because it groups to-gether topically related sentences; the first two sen-tences are about the location of the stoa; the nextthree convey information about the building event;the following two are about the monument’s use;and the last three are about its condition throughhistory. 32 We mark the sentence groups in the firsttext by curly brackets, but the brackets would not beshown to end-users. In longer texts, sentence groupsmay optionally be shown as separate paragraphs orsections, which is why we call them sections.

To allow message triples (and sentences) to begrouped by topic, the domain author may definesections and assign each property (excluding mod-ified ones) to exactly one section. In the exampleabove, locationSection, buildSection, useSection, andconditionSection would be be declared to be indi-viduals of the Section class of Naturalowl’s gener-ation resources ontology. Properties are assigned tosections using annotation properties. For example,the following statements specify that isInArea andisNextTo are properties of locationSection. The state-ments would cause all message triples involving thetwo properties to be placed in locationSection.

AnnotationAssertion(nlowl:hasSection

:isInArea dgr:locationSection)

AnnotationAssertion(nlowl:hasSection

:isNextTo dgr:locationSection)

A partial order of properties inside their sections canalso be specified, as shown below.

32Topically related sentences often share identical or seman-tically related words. Hence, grouping them also increases

the lexical cohesion [72] of adjacent sentences.

19

AnnotationAssertion(nlowl:hasOrder

:isInArea "1"^^xsd:nonNegativeInteger)


:isNextTo "2"^^xsd:nonNegativeInteger)

Message triples of properties with smaller hasOrder

values are always placed before triples of propertiesof the same section with larger hasOrder values. 33 Iftwo message triples involve properties of the samesection with the same hasOrder values, their relativeorder within their section is selected randomly.

Similarly, a partial order can be imposed on sec-tions, as shown below. Again, sections with smallerhasOrder values (and the sentences they contain) areplaced before all other sections with larger hasOrder

values. Sections with identical hasOrder values caneither precede or follow each other.


:locationSection "1"^^xsd:nonNegativeInteger)

When using Naturalowl’s Protege plug-in, thedomain author orders sections and properties with-out seeing the hasOrder values, which are automat-ically generated. The sections and partial orderscould be made sensitive to different user types, per-haps also different languages, though we have notencountered applications that required this.

The text planning algorithmNaturalowl’s text planning algorithm is summa-

rized in Figure 4. If the message triples to be or-dered include triples that describe second-level tar-gets, i.e., triples 〈S, P,O〉whose owner S is a second-level target, then the triples of the primary and eachsecond-level target are ordered separately. The or-dered triples of each second-level target are then in-serted into the ordered list of the primary target’striples immediately after the first triple that intro-duces the second-level target, i.e., immediately afterthe first triple whose O is the second-level target.

Further related work on text planningNaturalowl’s ordering of properties and sections

is in effect similar to using text schemata [116],roughly speaking domain-dependent patterns thatspecify the possible arrangements of different typesof sentences (or other segments). The limitations oftext schemata in more general settings have beendiscussed, for example, by Hovy [80] and Moore andParis [128]. For the kinds of texts that Naturalowl

33The annotations that assign properties to sections andspecify their partial order apply to all the triples of the

particular properties, including triples involving modifiers.

procedure orderMessageTriples

inputs:

t[0]: primary target

t[1], ..., t[n]: second-level targets

L[0]: unordered list of triples describing t[0]

...

L[n]: unordered list of triples describing t[n]

SMap: mapping from properties to sections

SOrder: partial order of sections

POrder: partial order of properties within sections

output:

ordered list of message triples

steps:

for i := 0 to n {

orderMessageTriplesAux(L[i], SMap, SOrder, POrder)}

for i := 1 to n {

insertAfterFirst(<t[0], _, t[i]>, L[0], L[i])}

return L[0]

procedure orderMessageTriplesAux

inputs:

L: unordered list of triples about a single target

SMap: mapping from properties to sections

SOrder: partial order of sections

POrder: partial order of properties within sections

variables:

S[1], ..., S[k]: lists, each with triples of one section

output:

ordered list of message triples about single target

steps:

<S[1], ..., S[k]> := splitInSections(L, SMap)

for i := 1 to k {

S[i] := orderTriplesInSection(S[i], POrder)}

<S[1], ..., S[k]> :=

reorderSections(S[1], ..., S[k], SOrder)

return concatenate(S[1], ..., S[k])

Figure 4. Algorithm used to order message triples.

is intended to generate, however, the current order-ing of properties and sections seems adequate.

Sentence ordering has also been studied exten-sively in extractive multi-document text summariza-tion. For example, Barzilay et al. [9] automaticallygroup the sentences that have been selected to be in-cluded in a summary into topical blocks; the selectedsentences roughly correspond to our message triplesand the topical blocks correspond to our sections.Subsequently, the blocks and the sentences insidethem are automatically ordered. Barzilay et al. alsoprovide experimental evidence showing that group-ing sentences into topical blocks affects the compre-hension and acceptability of the summaries.

Methods similar to those of Barzilay et al. [9]could be used in our case to automatically acquirethe mapping from properties to sections, as well asthe order of sections and properties, instead of pro-viding them manually. This would require, however,a corpus of documents describing individuals andclasses of the domain ontology; and the sentences

20

of the corpus would have to be semantically taggedwith the corresponding message triples, or at leasttheir properties. Each document of the corpus couldthen be automatically segmented into topics, for ex-ample using methods discussed by Hearst [77]; or insome domains it may be possible to use Wikipedia orother documents with explicit sections [148]. Prop-erties frequently expressed by sentences of the sametopical segment would be placed in the same section.Inside a section, a property p1 could be ordered be-fore a property p2, if more sentences expressing p1preceded sentences expressing p2 in the corpus thanthe other way round; Barzilay et al. [9,148] call thismajority ordering. The ordering of sections could beacquired similarly. Consult also Duboue and McKe-own [50] and Dimitromanolaki and Androutsopou-los [49] for other methods to learn to order sentencesor other segments in nlg; these methods, however,also require semantically tagged corpora.

An alternative is to generate a candidate text foreach possible sentence ordering. The best candidatetext can then be selected by a model trained to ranktexts by their local coherence. Ranking models ofthis kind can be trained on corpora, without requir-ing their documents to be semantically tagged [12].This overgenerate and rank approach, however, istractable only when the message triples to be ex-pressed are very few, since for n triples, there are n!candidate texts; we return to this point when dis-cussing sentence aggregation. Latent topic models,which do not require semantically tagged corpora,have also been used to rank candidate sentence or-derings [13] or to directly order sentences or para-graphs [55,32]; some of these models attempt to com-bine local with global coherence constraints.

2.2. Micro-planning

The processing stages we have discussed so far se-lect and order the message triples to be expressed.The next stage, micro-planning, consists of threesub-stages: lexicalization, sentence aggregation, andgeneration of referring expressions.

2.2.1. LexicalizationDuring lexicalization, nlg systems usually turn

messages (in our case, message triples) to abstractsentence specifications. The mechanisms used dur-ing this stage and the level of abstraction of the re-sulting specifications vary across nlg systems, fromsimple text templates with slots that are filled in

to produce almost final sentences, to more complexrules, possibly with preconditions and actions, whichmay produce syntax trees [15,31,117,166].

In Naturalowl, for every property of the domainontology and every supported natural language, thedomain author may specify one or more template-like sentence plans to indicate how message triplesinvolving that property can be expressed. The prop-erties are mapped to sentence plans using owl anno-tation assertions. For example, the usedDuringPeriod

property of page 19 is mapped below to a sentenceplan whose identifier is usedDuringPeriodEnglish.

AnnotationAssertion(nlowl:hasSentencePlan

:usedDuringPeriod

dgr:usedDuringPeriodEnglish)

The annotation property hasSentencePlan is definedin Naturalowl’s generation resources ontology, asindicated by its nlowl prefix. Sentence plan iden-tifiers are prefixed with dgr, since sentence plansare domain-dependent. We discuss below how sen-tence plans themselves, like usedDuringPeriodEnglish,are specified, but first a slight deviation is necessary,to briefly discuss Naturalowl’s lexicon entries.

Lexicon entriesFor each verb, noun, or adjective that the domain

author wishes to use in the sentence plans, a lexi-con entry has to be provided, which specifies the in-flectional forms of that word among other informa-tion. 34 All the lexicon entries are multilingual (cur-rently bilingual); this could allow sentence plans tobe reused across similar languages when no betteroption is available, as discussed elsewhere [4]. Fig-ure 5 shows the lexicon entry for the verb whose En-glish base form is “find”. The entries for nouns andadjectives are similar; we provide examples below,when discussing the generation of referring expres-sions. The statements of Figure 5 specify that thereis a lexicon entry whose identifier is toFindLex; theEnglish and Greek parts of the lexicon entry havethe identifiers toFindEnglish and toFindGreek, respec-tively. The English part shows that the base form is“find”, that the simple past form is “found” etc. Inpractice, the lexicon entries are created by using theProtege plug-in, as illustrated in Figure 6, insteadof writing directly statements like those of Figure 5.

Most of the inflectional forms of English verbs,nouns, and adjectives could be automatically pro-duced from the base forms by using relatively sim-

34The lexicon entries of closed-class words, like determiners

and prepositions, are domain-independent.

21

ClassAssertion(nlowl:LexiconEntry dgr:toFindLex)

ObjectPropertyAssertion(nlowl:hasEnglishLexEntry

dgr:toFindLex dgr:toFindEnglish)

ObjectPropertyAssertion(nlowl:hasGreekLexEntry

dgr:toFindLex dgr:toFindGreek)

ClassAssertion(:EnglishLexEntry :toFindEnglish)

DataPropertyAssertion(:baseForm

:toFindEnglish "find"^^xsd:string)

DataPropertyAssertion(:simplePres3rdSing

:toFindEnglish "finds"^^xsd:string)

DataPropertyAssertion(:presParticiple

:toFindEnglish "finding"^^xsd:string)

DataPropertyAssertion(:simplePast

:toFindEnglish "found"^^xsd:string)

DataPropertyAssertion(:pastParticiple

:toFindEnglish "found"^^xsd:string)

ClassAssertion(:GreekLexEntry :toFindGreek)

...

Figure 5. A bilingual lexicon entry for the verb “to find”.

Figure 6. Creating a lexicon entry with Naturalowl’s Protegeplug-in. The English part of the entry is shown.

ple morphology rules. We hope to exloit an exist-ing English morphology component, such as that ofsimplenlg [63], for this purpose in future work. 35

Similar morphology rules for Greek were used in m-piro’s authoring tool [4], and we hope to includethem in a future version of Naturalowl. Rules of thiskind would reduce the time a domain author spendscreating lexicon entries; for example, the Protegeplug-in could suggest automatically generated in-flected forms, and the author could check them andcorrect irregular forms. We note, however, that inthe domain ontologies we have considered, a fewdozens of lexicon entries for verbs, nouns, and adjec-tives suffice; we provide estimates of the domain au-thor’s effort when discussing the trials that we con-ducted. Hence, even without facilities to automati-cally produce inflectional forms, creating the lexicon

35See http://code.google.com/p/simplenlg/.

entries using the plug-in is rather trivial.Another possibility would be to exploit a general-

purpose lexicon, such as WordNet [56]. 36 General-purpose lexicons, however, often do not cover thehighly technical concepts of domain ontologies.

Sentence plansIn Naturalowl, a sentence plan consists of a se-

quence of slots, and instructions specifying how tofill them in; once the slots have been filled in, theircontents are concatenated to produce a sentence.The number of slots of each sentence plan, their or-der, and the instructions that specify how to fill themin are represented in owl, using concepts from Nat-uralowl’s generation resources ontology.

Figure 7 shows the owl statements that definethe usedDuringPeriodEnglish sentence plan of our ear-lier example; again, in practice the domain authordefines sentence plans using the Protege plug-in, asillustrated in Figure 8, which produces the corre-sponding owl statements. The first two statementsof Figure 7 assert that usedDuringPeriodEnglish is asentence plan for English. The third statement al-lows the sentence plan to be aggregated; we discusssentence aggregation below.

The next five statements define the first slot ofthe sentence plan. As with annotation events, slotsare treated as individuals, but their identifiers (e.g.,:slot1) are automatically generated by the Protegeplug-in and they are not shown to the domain au-thor. The statements declare the slot to be thefirst one; they also require it to be filled in withan automatically generated referring expression forthe triple’s owner (S). For example, if the triple toexpress is <:stoaZeusEleutherios, :usedDuringPeriod,

:classicalPeriod>, an appropriate referring expres-sion for S may be a demonstrative noun phrase like“this stoa”, a pronoun (“it”), or the monument’snatural language name (“the Stoa of Zeus Eleuthe-rios”). We discuss the generation of referring ex-pressions below, along with mechanisms to specifynatural language names. The useCase requires thegenerated referring expression to be in nominativecase (e.g., “it” or “this stoa”, as opposed for exam-ple to the genitive case expressions “its” or “thisstoa’s”, as in “This stoa’s height is 5 meters”).

The next seven statements define the second slot,to be filled in with a form of the verb whose lexi-con entry is toUseVerb. The verb form must be in the

36Consult http://www.w3.org/TR/wordnet-rdf/ for an owl

version of WordNet.

22

ClassAssertion(nlowl:SentencePlan

dgr:usedDuringPeriodEnglish)

DataPropertyAssertion(nlowl:forLanguage

dgr:usedDuringPeriodEnglish

nlowl:englishLanguage)

DataPropertyAssertion(nlowl:aggregationAllowed

dgr:usedDuringPeriodEnglish "true"^^xsd:boolean)

ObjectPropertyAssertion(nlowl:hasSlot

dgr:usedDuringPeriodEnglish _:slot1)

DataPropertyAssertion(nlowl:hasOrder

_:slot1 "1"^^xsd:nonNegativeInteger)

ClassAssertion(nlowl:forOwnerSlot _:slot1)

DataPropertyAssertion(nlowl:refExpressionType

_:slot1 nlowl:autoRefExpression)

DataPropertyAssertion(nlowl:useCase

_:slot1 nlowl:nominativeCase)





ObjectPropertyAssertion(nlowl:useLexiconEntry

_:slot2 dgr:toUseVerb)

DataPropertyAssertion(nlowl:useTense

_:slot2 nlowl:simplePast)

DataPropertyAssertion(nlowl:useVoice

_:slot2 nlowl:passiveVoice)

DataPropertyAssertion(nlowl:usePolarity

_:slot2 "true"^^xsd:boolean)

DataPropertyAssertion(nlowl:agreeWith

_:slot2 _:slot1)





ObjectPropertyAssertion(nlowl:usePreposition

_:slot3 nlowl:duringPrepEnglish)





ClassAssertion(nlowl:forFillerSlot _:slot4)

DataPropertyAssertion(nlowl:useCase

_:slot4 nlowl:accusativeCase)

DataPropertyAssertion(nlowl:useBullets

_:slot4 "false"^^xsd:boolean)

Figure 7. owl statements defining a sentence plan for sen-

tences like “It was used during the Classical period”.

simple past and passive voice (“was used” or “wereused”), in positive polarity (as opposed to the neg-ative polarity “was not used”) and its number mustagree with the number of the expression in the firstslot (the subject); for example, we want to gener-ate “The Stoa of Zheus Eleutherios was used”, but“Stoas were used”.

The third slot is filled in with the preposition

“during”. The fourth slot must be filled in with anexpression for the filler (O) of the message triple. Inthe case of <:stoaZeusEleutherios, :usedDuringPeriod,

:classicalPeriod>, the slot would be filled in with thenatural language name of classicalPeriod. 37 The ex-pression’s case is set to accusative; English preposi-tions usually require their noun phrase complementsto be in accusative case (e.g., “on him”). In Greekand other languages, grammatical cases have morenoticeable effects.

The sentence plan of Figure 7 produces sentenceslike the following two.

[slot1This stoa] [slot2was used] [slot3during] [slot4 the

Classical period].

[slot1The Stoa of Zeus Eleutherios] [slot2was used]

[slot3during] [slot4 the Classical period, the Hellenistic

period, and the Roman period].

Changing the value of useBullets in the fourth slot totrue would produce sentences with bullet lists, likethe following one, when the filler is a disjunction ora conjunction.

The Stoa of Zeus Eleutherios was used during:

– the Classical period,– the Hellenistic period, and

– the Roman period.

More generally, the instructions of a sentence planmay indicate that a slot should be filled in with oneof the following (i–vii):

(i) A referring expression for the S (owner) of themessage triple. A sentence plan may specify a par-ticular type of referring expression to use (e.g., al-ways use the natural language name of S) or, as inthe example of Figure 7, it may allow the system toautomatically produce the most appropriate type ofreferring expression depending on the context.

(ii) A verb for which there is a lexicon entry, in aparticular inflectional form (e.g., a verb in a partic-ular tense, voice etc.), possibly in a form that agreeswith another slot (e.g., for subject-verb agreement).The verb’s polarity can also be manually specifiedor, if the filler (O) of the message triple is a Booleanvalue, the polarity can be automatically set to matchthat value (e.g., to produce “It does not have a built-in flash” when O is false).

(iii) A noun or adjective from the lexicon. Thecase, number, and gender can be set to a specificvalue. Otherwise the form of the noun or adjec-

37Future versions of Naturalowl may allow a referring ex-pression for O other than the natural language name to be

produced (e.g., a pronoun), as with S.

23

Figure 8. Defining a sentence-plan with the Protege plug-in.

tive can be set to agree with another slot (e.g. foradjective-noun agreement).

(iv) A preposition.(v) A fixed string. For example, we may want the

sentence to start with “It is now believed that”.(vi) An expression for the O (filler) of the triple.

If O is an individual or class, then the expression isO’s natural language name. If O is a datatype value(e.g., an integer), then the value itself is insertedin the slot. If O is a disjunction or conjunction ofdatatype values or individuals or classes, then theslot is filled in with a disjunction or conjunction ofthe datatype values or the natural language namesof the individuals or classes.

(vii) A concatenation of property values of O, pro-vided that O is an individual. For example, we mayneed to express a message triple like the first onebelow, whose anonymous node :n is linked to botha numeric value (via hasAmount) and an individualstanding for the currency (via hasCurrency) by thenext two triples. 38

<:tecra8, :hasPrice, _:n>

<_:n, :hasAmount, "850"^^xsd:float>

<_:n, :hasCurrency, :euroCurrency>

We would want the sentence plan to include a slotfilled in with the concatenation of the hasAmount valueand the natural language name of the hasCurrency

value (“Euro” in English, “Eur¸” in Greek) of theoriginal triple’s O ( :n). If a property vaue to beconcatenated is a datatype value, then the value

38The last two triples would be automatically retrieved from

the domain ontology, since the sentence plan of the firsttriple requires them, even if they are not selected by contentselection. Their interest scores would be automatically set to

zero, to avoid generating sentences expressing them directly.

itself is concatenated. If it is an individual (e.g.,euroCurrency), the individual’s natural languagename is concatenated. If the O of the original tripleis a disjunction or( :n1, :n2, ...) or a conjunctionand( :n1, :n2, ...), then the slot is filled in with adisjunction or conjunction of the specified propertyvalues of :n1, :n2, etc.

Default sentence planIf no sentence plan has been provided for a partic-

ular property of the domain ontology, Naturalowluses a default sentence plan, consisting of three slots:

– The first slot is filled in with an automatically gen-erated referring expression for the triple’s owner(S) in nominative case.

– The second slot is filled in with the owl identifierof the property (without namespace) as a string,with underscores and dashes replaced by spaces,and additional spaces inserted at points wherecapitalization changes or groups of digits start. 39

– The third slot is filled in with an appropriate ex-pression for the triple’s filler (O), as discussedabove, in accusative case (if applicable).

For the usedDuringPeriod triple of page 19, the de-fault sentence plan would produce the sentence:

Stoa zeus eleutherios used during period classical period,

hellenistic period, and roman period.

39Power [137] reports that heuristic tokenization rules ofthis kind usually produce reasonable tokens. Fliedl et al.

[57] provide further examples of owl identifiers to be to-

kenized. Cimiano et al. [34] propose a more elaborate ap-proach, whereby grammar rules are applied to tokenized

identifiers or rdfs:label strings (discussed below).

24

We assumed in the sentence above that the natu-ral language names of the individuals have not beenprovided either; mechanisms to specify natural lan-guage names are discussed below. In this case, Nat-uralowl uses the owl identifiers of the individu-als (e.g., stoaZeusEleutherios) as natural languagenames, applying the same tokenization rules that ituses for property identifiers.

Using rdfs:label stringsowl properties (and other elements of owl on-

tologies) can be labeled with strings in multiple nat-ural languages using the rdfs:label annotation prop-erty, which is defined in the rdf and owl standards.For example, the usedDuringPeriod property could belabeled with “was used during” as below; there couldbe similar labels for Greek and other languages.

AnnotationAssertion(rdfs:label :usedDuringPeriod

"was used during"@en)

If an rdfs:label string has been specified for theproperty of a message triple, Naturalowl uses thatstring in the second slot of the default sentence plan.The quality of the resulting sentences can, thus, beimproved, if the rdfs:label strings are more natu-ral phrases than the tokenized property identifiers.With the rdfs:label shown above, the default sen-tence plan would produce the following sentence.

Stoa zeus eleutherios was used during classical period,

hellenistic period, and roman period.

Even with rdfs:label strings, however, the defaultsentence plan may produce sentences with disfluen-cies; for example, there may be violations of num-ber agreement, or referring expressions with wrongcases (especially in Greek). Furthermore, the defaultsentence plan does not indicate which parts of thesentences are verbs or prepositions, and this doesnot allow the system to apply many of the sentenceaggregation rules discussed below. A further limita-tion of the default sentence plan is that it does notallow the slots for S and O to be preceded or fol-lowed, respectively, by any other expression.

Sentence plans for domain-independent propertiesThe domain author does not need to provide sen-

tence plans for domain-independent properties (e.g.,instanceOf, isA, see Tables 4–5). These propertieshave fixed semantics, independent of the domain on-tology; hence, built-in sentence plans can be used.We summarize the English built-in sentence plansin Table 6; the Greek ones are very similar. We donot show the sentence plans for negated domain-

independent properties (e.g., not(isA)), which arevery similar. To save space we show the sentenceplans as templates, rather than owl statements.

Additional slot restrictions not shown in Figure6 require, for example, subject-verb number agree-ment and the verb forms (“is” or “was”) to be inpresent tense. Note also that information providedwhen specifying the natural language names of in-dividuals and classes, discussed below, shows if def-inite or indefinite articles or no articles at all shouldbe used (e.g., “the n97 mini”, “exhibit 24”, “a St.Emilion” or “the St. Emilion” or simply “St. Emil-ion”), and what the default number of the names is(e.g., “A wine color is” or “Wine colors are”).

In some domains, it may actually be desirable toslightly modify the built-in sentence plans. For ex-ample, in a museum context we may wish to generatesentences like “An aryballos was a kind of vase” in-stead of “An aryballos is a kind of vase”. The built-in sentence plans can be modified via the Protegeplug-in or by editing directly the corresponding owlstatements, as with other sentence plans.

Sentence plans for modified propertiesThe sentence plans for modified properties (e.g.,

minCardinality(manufacturedBy), see Tables 4–5) areautomatically produced from the sentence plans ofthe unmodified properties (e.g., manufacturedBy), asshown in Table 7; again, we omit details such assubject-verb agreement, voice, tense etc. Hence, thedomain author provides sentence plans only for the(unmodified) properties of the domain ontology.

Specifying the appropriateness of sentence plansMultiple sentence plans may be provided for the

same property of the domain ontology and the samelanguage. Different appropriateness scores can thenbe assigned to alternative sentence plans per usertype. This allows specifying, for example, that a sen-tence plan that generates sentences like “This am-phora depicts Miltiades” is less appropriate wheninteracting with children, compared to an alterna-tive sentence plan that uses a more common verb(e.g., “shows”). Sentence plans are assigned appro-priateness scores using annotation events, much aswhen assigning interest scores to properties.

If multiple sentence plans are available for thesame property and user type, Naturalowl prefersthe sentence plan with the highest appropriatenessscore the first time it needs to convey a messagetriple of that property to a particular user of thattype. The second time that a triple of the same prop-

25

forms of message triples and example message triples and

corresponding built-in sentence plans possible resulting sentences

<S, instanceOf, O> <:eos450d, instanceOf, :PhotographicCamera>

ref(S) toBeVerb name(indef, O) The eos 450d is a photographic camera.

<S, instanceOf, O> <:eos450d, instanceOf, :Cheap>

ref(S) toBeVerb name(adj, O) The eos 450d is cheap.

<S, oneOf, O> <:WineColor, oneOf, or(:white, :rose, :red)>

ref(S) toBeVerb name(O) A wine color is white, rose, or red.

<S, differentIndividuals, O> <:n97, differentIndividuals, :n97mini>

ref(S) toBeVerb not identical to name(O) The n97 is not identical to the n97 mini.

<S, sameIndividual, O> <:eos450d, sameIndividual, :rebelXSi>

ref(S) toBeVerb identical to name(O) It is identical to the Rebel xsi.

<S, isA, O> <:StEmilion, isa, :Bordeaux>

ref(S) toBeVerb a kind of name(noarticle, O) St. Emilion is a kind of Bordeaux.

<S, isA, O> <:StEmilion, isa, :Red>

ref(S) toBeVerb name(adj, O) St. Emilion is red.

Table 6

Built-in English sentence plans for domain-independent properties. The notation ref(ξ) stands for a referring expression

for ξ; name(ξ) is the natural language name of ξ; name(indef, ξ) and name(noarticle, ξ) mean that the name should be a nounphrase with an indefinite or no article, respectively. Sentence plans involving name(adj, ξ) are used when the natural language

name of ξ is a sequence of one or more adjectives; otherwise the sentence plan of the previous row is used.

erty has to be conveyed to the same user, it prefersthe second most appropriate sentence plan, providedthat its appropriateness is positive, and so on, untilwe are left with no unused sentence plan with posi-tive appropriateness for the property. At that point,the process restarts from using the most appropri-ate sentence plan. Sentence plans with negative orzero appropriateness are used only when there is noalternative sentence plan with a positive score. Au-tomatically constructed sentence plans for modifiedproperties inherit the appropriateness of the sen-tence plans they are constructed from.

Even when there is only one user type, multi-ple sentence plans per property may be desirableto avoid repeating the same sentences. Automaticparaphrase generation [3,112] could be used to sug-gest alternative sentence plans to the domain au-thor. It may also be possible to obtain sentence plansfrom FrameNet [111], as suggested by Dannels [42].

A note on templates and sentence plansAlthough we often informally show them as tem-

plates, Naturalowl’s sentence plans are not sim-ply strings with slots filled in with elements of themessage triples. Recall, for example, that a sentenceplan may specify the lexicon entry of a verb, thedesired tense and voice, and that the verb should

match the number of a referring expression, rely-ing on subsequent processing stages to produce thesurface (final) form of the sentence (e.g., the exactverb form and referring expression). In that sense,Naturalowl’s sentence plans are similar to expres-sions of sentence planning languages (e.g., spl [89])that are used to formulate the inputs to generic sur-face realizers, like fuf/surge [54], kpml [15], real-pro [107], nitrogen/halogen [105,104,106], andopenccg [173]; see also Guo et al. [67], Varges andMellish [168], and the references therein.

Unlike the inputs to most generic surface real-izers, however, Naturalowl’s sentence plans leavefewer decisions to subsequent processing stages. Inmany generic realizers, for example, the input wouldspecify the base forms of the content words to use,and features like voice, tense, polarity etc. The cor-rect order of the words (or syntactic constituents),several inflectional features (e.g., numbers, cases),and often the necessary function words (e.g., arti-cles, prepositions) would be automatically selected,usually relying on large-scale grammars or statisti-cal models. By contrast, information of this kind isexplicitly specified in Naturalowl’s sentence plans.This has the disadvantage that our sentence plans of-ten include information that could be automatically

26

example forms of triples involving unmodified and example triples involving unmodified and modified

modified properties and the corresponding sentence plans properties and possible resulting sentences

<S, :manufacturedBy, O> <:tecraA8, :manufacturedBy, :toshiba>

ref(S) toManufactureVerb byPrepEnglish name(O) Tecra A8 is manufactured by Toshiba.

<S, minCardinality(:manufacturedBy), n:R> <:Laptop, minCardinality(:manufacturedBy), 1:Company>

ref(S) toManufactureVerb byPrepEnglish at least name(n,R) A laptop is manufactured by at least one company.

<S, :currentMuseum, O> <:exhibit24, :currentMuseum, :delosMuseum>

ref(S) toBeVerb inPrepEnglish name(O) Exhibit 24 is in the Museum of Delos.

<S, maxCardinality(:currentMuseum), n:R> <:Exhibit, maxCardinality(:currentMuseum), 1:Museum>

ref(S) toBeVerb inPrepEnglish at most name(n,R) An exhibit is in at most one museum.

<S, :madeFromGrape, O> <:StEmilion, :madeFromGrape, :cabernetSauvignonGrape>

ref(S) toMakeVerb fromPrepEnglish name(O) St. Emilion is made from Cabernet Sauvignon grape.

<S, exactCardinality(:madeFromGrape), n:R> <:StEmilion, exactCardinality(:madeFromGrape), 1>

ref(S) toMakeVerb fromPrepEnglish exactly name(n,R) St. Emilion is made from exactly one grape.

<S, :madeFromGrape, O> <:Assyrtiko, :madeFromGrape, :assyrtikoGrape>

ref(S) toMakeVerb fromPrepEnglish name(O) The Assyrtiko wine is made from Assyrtiko grape.

<S, allValuesFrom(:madeFromGrape), O> <:GreekWine, allValuesFrom(:madeFromGrape), :GreekGrape>

ref(S) toMakeVerb fromPrepEnglish only name(plural, indef, O) Greek wines are made from only Greek grapes.

<S, :manufactures, O> <:toshiba, :manufactures, :tecraA8>

ref(S) toManufactureVerb name(O) Toshiba manufactures Tecra A8.

<S, someValuesFrom(:manufactures), O> <:LaptopManuf, someValuesFrom(:manufactures), :Laptop>

ref(S) toManufactureVerb at least name(1, O) A laptop manufacturer manufactures at least one laptop.

Table 7

Automatically constructed sentence plans for modified properties. In each cell of the left column, the sentence plan in the

last line is automatically constructed from the sentence plan in the second line. Square brackets indicate optional arguments.The notation ref(ξ) stands for a referring expression for ξ; name(ξ) is the natural language name of ξ; name(n, κ) is a noun

phrase for n individuals of class κ, and name(plural, indef, κ) is a plural indefinite noun phrase for individuals of κ. When R isunspecified, it is taken to be the class that has been declared as the range of the unmodified property, if the range is a named

class; if the range is an unnamed class, name(n,R) generates an expression like “n entities”.

obtained from large-scale grammars or corpora.On the other hand, the input to generic surface

realizers often includes information pertaining tonon-elementary linguistic concepts (e.g., syntacticcategories, subcategories, and features of a partic-ular syntax theory) and concepts of a large-scalehigh-level domain-independent ontology, usuallycalled the upper model [14]. Hence, linguistic ex-pertise (e.g., in Systemic Grammars [71] in thecase of kpml [15]) and effort to understand theupper model are often required. By contrast, Natu-ralowl’s sentence plans require the domain authorto be familiar with only elementary linguistic con-cepts (e.g., tense, voice, number, case), and they donot require familiarity with an upper model.

Overall, Naturalowl’s sentence plans, like the en-tire system, are intended to be easier to master by

domain authors that are familiar with Semantic Webconcepts and the domain ontology, but not compu-tational linguistics. It would, however, be worth ex-ploring in future work how generic surface realizerscould be exploited, especially realizers that do notrequire linguistic expertise. In Ratnaparkhi’s real-izer [142], for example, the input is a set of attribute-value pairs specifying the semantics of the sentenceto be produced; a corpus annotated with attributes,however, is required to extract templates from. Inthe realizer of Wan et al. [172], the input is an un-ordered set of words; the system orders them by con-sidering possible dependency trees that span them.

We also note that Naturalowl’s sentence plansare simpler than, for example, the templates of Buse-mann and Horacek [31] or McRoy et al. [117], in thatthey do not allow, for instance, conditionals or re-

27

cursive invokation of other templates. See also Re-iter [144] for a discussion of the advantages and dis-advantages of template-based vs. theoretically moreprincipled nlg systems, and van Deemter et al. [166]for a discussion of how sentence templates can beenriched with syntactic and other information, blur-ring the distinction between simple templates andmore complex sentence plans.

When corpora of target texts annotated with themessage triples they express are available, templatescan also be automatically extracted, for example asin the systems of Ratnaparkhi [142] and Angeli etal. [5]. Statistical methods that can, in effect, jointlyperform content selection, lexicalization, and sur-face realization, have also been proposed [108,98,99],for cases where training target sentences and corre-sponding semantic inputs are available, but they arecurrently limited to generating single sentences fromsemantic inputs that have the form of flat recordscontaining fields and field values.

Specifying natural language namesThe domain author can assign natural language

(nl) names to the domain ontology’s individualsand named classes; recall that by named classes wemean classes that have owl identifiers. If an indi-vidual or named class is not assigned an nl name,then its rdfs:label or a tokenized form of its identi-fier are used instead, as already discussed. The nlnames that the domain author provides are specifiedmuch as sentence plans, i.e., as collections of slotswhose contents are concatenated. For example, wemay specify that the English nl name of the classItalianWinePiemonte is the concatenation of the fol-lowing slots; we explain the slots further below.

[indef an] [adj Italian] [headnoun wine] [prep from] [defthe] [noun Piemonte] [noun region]

This would allow Naturalowl to generate the sen-tence shown below from the following message triple;a tokenized form of wine32’s identifier is used.

<:wine32, instanceOf, :ItalianWinePiemonte>

Wine 32 is an Italian wine from the Piemonte region.

Similarly, we may assign the following nl names tothe individuals classicalPeriod, stoaZeusEleutherios,gl2011, and the classes ComputerScreen and Red. Thedomain author can request the words of particu-lar slots to be capitalized (e.g., “the Classical pe-riod”). Also, Naturalowl makes no distinction be-tween common and proper nouns; both are enteredas nouns in the lexicon, and they may be multi-word.

[def the] [adj Classical] [headnoun period]

[def the] [headnounstoa] [prepof] [nounZeus Eleutherios]

[headnoun GL-2011]

[indef a] [noun computer] [headnoun screen]

[headadj red]

These nl names could be used to express the mes-sage triples shown below; consult also Table 6.


:classicalPeriod>

The Stoa of Zeus Eleutherios was used during the Classical

period.

<:gl2011, instanceOf, :ComputerScreen>

GL-2011 is a computer screen.

<:gl2011, instanceOf, :Red>

GL-2011 is red.

The color of gl2011 could also be expressed via aproperty of the domain ontology, as in:

<:gl2011, :hasColor, :redColor>

We would assign to the individual redColor the samenl name we assigned to the class Red.

Unlike tokenized identifiers and rdfs:label strings,the nl names carry additional linguistic information(e.g., grammatical categories of words), which al-lows, for example, the aggregation stage, discussedbelow, to combine sentences as in the following cases.

It was used during the Classical period, the Hellenistic

period, and the Roman period.⇒ It was used during the

Classical, the Hellenistic, and the Roman period.

It is a computer screen. It is red.⇒ It is a red computer

screen.

More precisely, each nl name is a sequence ofslots, with accompanying instructions specifyinghow the slots are to be filled in. Each slot can befilled in with one of the following (i–v):

(i) An article, definite or indefinite (in English“the” or “a”). The article in the first slot (if present)is treated as the article of the overall nl name, butmultiple articles may be present in the same name,as in the Piemonte example above.

(ii) A noun or adjective flagged as the head (mainword) of the nl name. Exactly one head must bespecified per nl name and it must have a lexicon en-try. The number and case of the head, which is alsotaken to be the number and case of the overall nl

28

name, can be automatically adjusted per context.For example, different sentence plans may requirethe same nl name to be in nominative case whenused as a subject, but in accusative when used asthe object of a verb; and some aggregation rules, dis-cussed below, may require a singular nl name to beturned into plural. Using the lexicon entries, whichlist the inflectional forms of nouns and adjectives,Naturalowl can adjust the nl names accordingly.The gender of head adjectives can also be automat-ically adjusted, whereas the gender of head nouns isfixed and specified by their lexicon entries.

(iii) Any other noun or adjective, among thoselisted in the lexicon. The nl name may require aparticular inflectional form (e.g., number, case) tobe used, or it may require an inflectional form thatagrees with another slot of the nl name (e.g., foradjective-noun agreement).

(iv) A preposition.(v) Any fixed string. For example, words of gram-

matical categories that are not included in the lexi-con (e.g., adverbs) are entered as strings.

The owl representation of nl names is very sim-ilar to that of sentence plans; we do not discuss it tosave space. Again, in practice nl names are enteredvia the Protege plug-in. As with sentence plans, mul-tiple nl names can be specified for the same in-dividual or class, and they can be assigned differ-ent appropriateness scores per user type; this allowsmore common terminology (e.g., common names ofdiseases) to be used when generating texts for non-experts, as opposed to texts for experts (e.g., doc-tors). Naturalowl cycles through the available nlnames (with positive appropriateness scores) of eachindividual or class, as with sentence plans.

The domain author can specify (via the Protegeplug-in or in the owl representation of nl names)if the nl names of particular individuals or classesshould involve definite, indefinite, or no articles, andif the nl names should be in singular or plural bydefault. For example, the domain author may pre-fer the texts to mention the class of Aryballoi as asingle particular generic object (singular form witha definite article), or by using an indefinite singularor plural form, as shown below.

<:Aryballos, isA, :Vase>

The aryballos is a kind of vase.

An aryballos is a kind of vase.

Aryballoi are a kind of vase.

Notice that some of the sentence plans of Tables6 and 7 require a particular form (e.g., indefinite

or no article), which is produced by automaticallymodifying the nl names provided by the domainauthor; similar conversions are imposed by some ofthe aggregation rules discussed next.

In domain ontologies with very large numbers ofindividuals, manually providing nl names for allthe individuals may be impractical. Hence, it maybe necessary to use tokenized identifiers, existingrdfs:label strings, or rdfs:label strings automat-ically constructed (by using additional software)from string-valued properties of the domain ontol-ogy (e.g., properties linking person individuals tostrings containing their names and surnames). Wereturn to this issue when presenting the trials.

2.2.2. Sentence aggregationThe sentence plans of the previous section lead

to a separate sentence for each message triple. nlgsystems often aggregate sentences into longer onesto avoid lexical redundancy and improve readabil-ity. 40 In Naturalowl, the maximum number of sen-tences that can be aggregated to form a single longersentence is specified per user type via a propertycalled maxMessagesPerSentence. The following state-ment allows each new sentence to be formed by ag-gregating at most two original sentences, when in-teracting with children. In the museum applicationsNaturalowl was originally developed for, settingmaxMessagesPerSentence to 3 or 4 led to reasonabletexts for adult visitors, whereas a value of 2 was usedwhen interacting with children.

DataPropertyAssertion(nlowl:maxMessagesPerSentence

dgr:child "2"^^xsd:nonNegativeInteger)

The idea that the number of messages per sen-tence or text (see also maxMessagesPerPage on page 16)should depend on the user type is inherited fromilex and m-piro, and it was originally inspired bywork in the psychology of text comprehension, espe-cially by Kintsch et al. [94,95]. Message triples can beviewed as expressing simple ideas, and it has been ar-gued, roughly speaking, that sentences or texts withmany ideas are harder to process. Hence, less skilledreaders should benefit from texts with fewer mes-sages per sentence, and fewer messages per text. 41

Naturalowl’s sentence aggregation is performedby a set of manually crafted rules, intended to be

40There is also evidence that aggregation may improve fac-

tual recall and, more generally, learning [88,48], though wehave no such evidence for Naturalowl’s aggregation rules.41See, for example, Nenkova et al. [130] for other factors

that affect the perceived linguistic quality of texts.

29

domain-independent. We do not claim that this par-ticular set of rules, which was initially based on m-piro’s corresponding rules [118], is in any way com-plete, and we hope that it will be extended in futurework; see, for example, Dalianis [41] for a study ofaggregation types and a rich set of aggregation rules.Nevertheless, Naturalowl’s current rules already il-lustrate several aggregation opportunities that arisewhen generating texts from owl ontologies. We alsonote that when appropriate datasets are available,it may be possible to automatically train aggrega-tion modules [171,11], though this was not the casewith the domain ontologies we considered.

To save space, we discuss only English sentenceaggregation; Greek aggregation is similar. Also,we show mostly example sentences before and af-ter aggregation, but the rules actually operate onsentence plans and they also consider the messagetriples the sentence plans express. The rules areintended to aggregate short single-clause sentences,each with exactly one verb. Sentence plans thatproduce more complicated sentences (e.g., involvinglong canned texts) may be flagged by setting theiraggregationAllowed property to false (see Figure 7on page 23), to signal that aggregation should notaffect the resulting sentences.

Naturalowl’s aggregation rules apply almost ex-clusively to sentences that are adjacent in the order-ing produced by the text planner; the only exceptionare aggregation rules that involve messages aboutcardinality restrictions. Hence, depending on thetext planner’s ordering there may be more or feweraggregation opportunities; see, for example, Chengand Mellish [33] for discussion on the interaction be-tween aggregation and text planning. Also, Natu-ralowl’s aggregation rules operate on sentences ofthe same topical section, because aggregating topi-cally unrelated sentences often sounds unnatural.

The system’s aggregation is currently greedy. Foreach one of the rules discussed below, starting fromthose discussed first, the system scans the original(already ordered) sentences from first to last, andapplies the rule wherever possible, provided that therule’s application does not lead to a sentence ex-pressing more than maxMessagesPerSentence originalmessages. If a rule can be applied in multiple ways,for example to aggregate two or three sentences, theapplication that aggregates the most sentences with-out violating maxMessagesPerSentence is preferred.

Avoid repeating a noun with multiple adjectives: Re-call that message triples of the form 〈S, P,O1〉, . . . ,

〈S, P,On〉 for the same S and the same property P ofthe domain ontology will have already been mergedinto a single message triple 〈S, P, and(O1, . . . , On)〉.If the nl names of O1, . . . , On are, apart from pos-sible initial determiners, sequences of adjectives fol-lowed by the same head noun, then the head noundoes not need to be repeated. Let us consider thefollowing message triple.


and(:classicalPeriod, :hellenisticPeriod,

:romanPeriod)>

Assuming that the nl names of classicalPeriod,hellenisticPeriod, and romanPeriod correspond to“the Classical period”, “the Hellenistic period”,and “the Roman period”, the original sentence willrepeat “period” three times. The aggregation ruleomits all but the last occurrence of the head noun.

It was used during the Classical period, the Hellenistic

period, and the Roman period.⇒ It was used during the

Classical, the Hellenistic, and the Roman period.

The rule above actually shortens a single sentence,which expresses, however, a message triple formedby merging multiple triples of the same S and P .

Cardinality restrictions and values: This is actuallya set of rules, summarized in Tables 8 and 9. 42 Theserules aggregate all the sentences (not necessarily ad-jacent ones) that express message triples of the form〈S,M(P ), O〉 and 〈S, P,O〉, for the same S and P ,with M being any of minCardinality, maxCardinality,or exactCardinality. When these rules are applied,MaxMessagesPerSentence is ignored.

Class and passive sentence: This rule aggregates (i)a sentence expressing a message triple of the form〈S, instanceOf, C〉 or 〈S, isA, C〉 and (ii) a passive im-mediately subsequent sentence expressing a singlemessage triple of the form 〈S, P,O〉, for the same S,where P is an (unmodified) property of the domainontology. The subject and auxiliary verb of the sec-ond sentence are omitted.

Bancroft Chardonnay is a kind of Chardonnay. It is

made in Bancroft. ⇒ Bancroft Chardonnay is a kind of

Chardonnay made in Bancroft.

Class and prepositional phrase: In a variant of theprevious rule, the second sentence involves the verb“to be” in the active simple present immediately

42We assume there are no inconsistencies in the triples (e.g.,

minimum and maximum cardinalities set to 4 and 3, respec-tively, for the same S and P ) and no redundancies (e.g.,

message triples for both exact and maximum cardinalities).

30

example rule application abstract rule description

<:model35, exactCardinality(:soldInCountry), 3>

Model 35 is sold in exactly three countries.

<:model35, :soldInCountry, and(:greece, :italy, :spain)>

Model 35 is sold in Greece, Italy, and Spain.

⇒ Model 35 is sold in exactly three countries:

Greece, Italy, and Spain.

<S, exactCardinality(prop ), n:R>

ref(S) . . . exactly name(n,R)

<S, prop, and(O1, . . . , On)>

ref(S) . . . name(O1, . . . , On)

⇒ ref(S) . . . exactly name(n,R):

name(O1, . . . , On)

<:model35, exactCardinality(:soldInCountry), 3>

Model 35 is sold in exactly three countries.

<:model35, :soldInCountry, and(:greece, :italy)>

Model 35 is sold in Greece and Italy.

⇒ Model 35 is sold in exactly three countries, including

Greece and Italy.

<S, exactCardinality(prop ), n:R>

ref(S) . . . exactly name(n,R)

<S, prop, and(O1, . . . , Om)> (m < n)

ref(S) . . . name(O1, . . . , Om)

⇒ ref(S) . . . exactly name(n,R), including

name(O1, . . . , Om)

<:model35, maxCardinality(:soldInCountry), 3>

Model 35 is sold in at most three countries.





<S, maxCardinality(prop ), n:R>

ref(S) . . . at most name(n,R)

<S, prop, and(O1, . . . , On)>

ref(S) . . . name(O1, . . . , On)

⇒ ref(S) . . . exactly name(n,R):

name(O1, . . . , On)





⇒ Model 35 is sold in at most three countries, including

Greece and Italy.

<S, maxCardinality(prop ), n:R>

ref(S) . . . at most name(n,R)

<S, prop, and(O1, . . . , Om)> (m < n)

ref(S) . . . name(O1, . . . , Om)

⇒ ref(S) . . . exactly name(n,R), including

name(O1, . . . , Om)

<:model35, minCardinality(:soldInCountry), 3>

Model 35 is sold in at least three countries.



⇒ Model 35 is sold in at least three countries:


<S, minCardinality(prop ), n:R>

ref(S) . . . at least name(n,R)

<S, prop, and(O1, . . . , On)>

ref(S) . . . name(O1, . . . , On)

⇒ ref(S) . . . at least name(n,R):

name(O1, . . . , On)


Model 35 is sold in at least three countries.



⇒ Model 35 is sold in at least three countries, including

Greece and Italy.

<S, minCardinality(prop ), n:R>

ref(S) . . . at least name(n,R)

<S, prop, and(O1, . . . , Om)> (m < n)

ref(S) . . . name(O1, . . . , Om)

⇒ ref(S) . . . at least name(n,R), including

name(O1, . . . , Om)

Table 8

Aggregation rules that merge one sentence expressing a cardinality constraint on a property prop of the domain ontology,

and another sentence expressing the values of prop . The notation ref(ξ) stands for a referring expression for ξ; name(n,R)is a noun phrase for n individuals of class R; name(ξ1, . . . , ξk) is a conjunction of the natural language names of ξ1, . . . , ξk.These rules are tried after the rules of Table 9.

31

example rule application abstract rule description


Model 35 is sold in at least two countries.



⇒ Model 35 is sold in at least two and at most three countries.

<S, minCardinality(prop ), n1:R>

ref(S) . . . at least name(n1, R)

<S, maxCardinality(prop ), n2:R>

ref(S) . . . at most name(n2, R) (n1 < n2)

⇒ ref(S) . . . at least name(n1, R) and at most name(n2, R)













<S, prop, and(O1, . . . , On2)>

ref(S) . . . name(O1, . . . , On2 )

⇒ ref(S) . . . exactly name(n2, R):

name(O1, . . . , On2 )




Model 35 is sold in at most four countries.



⇒ Model 35 is sold in at least two and at most four countries,

including Greece, Italy, and Spain.





<S, prop, and(O1, . . . , Om)> (n1 < m < n2)

ref(S) . . . name(O1, . . . , Om)

⇒ ref(S) . . . at least name(n1, R) and at most name(n2, R),

including name(O1, . . . , Om)







⇒ Model 35 is sold in at most three countries, including

Greece and Italy.





<S, prop, and(O1, . . . , On1)>

ref(S) . . . name(O1, . . . , On1 )

⇒ ref(S) . . . at most name(n2, R), including

name(O1, . . . , On1 )

Table 9

Aggregation rules that merge two sentences expressing cardinality constraints on the same property prop of the domainontology, and possibly a third sentence expressing the values of prop . The first rule of this table is applied only if the other

rules of this table cannot be applied. All the rules of this table are tried before the rules of Table 8. The notation ref(ξ) stands

for a referring expression for ξ; name(n,R) is a noun phrase for n individuals of class R; name(ξ1, . . . , ξk) is a conjunction ofthe natural language names of ξ1, . . . , ξk.

32

followed by a preposition, instead of being a passivesentence; the other conditions are as in the previousrule. The subject and verb of the second sentenceare omitted.

Bancroft Chardonnay is a kind of Chardonnay. It is from

Bancroft.⇒ Bancroft Chardonnay is a kind of Chardon-

nay from Bancroft.

Class and multiple adjectives: This rule aggregates(i) a sentence of the same form as in the previoustwo rules, i.e., a sentence expressing a message tripleof the form 〈S, instanceOf, C〉 or 〈S, isA, C〉 and (ii)one or more immediately preceding or subsequentsentences, each expressing a single message triple〈S, Pi, Oi〉, for the same S, where Pi are (unmodi-fied) properties of the domain ontology. Each of thepreceding or subsequent sentences must involve theverb “to be” in the active simple present immedi-ately followed by only an adjective. The adjectivesare absorbed into sentence (i) maintaining their or-der.

This is a motorbike. It is red. It is expensive. ⇒ This is

a red, expensive motorbike.

Same verb conjunction/disjunction: When there isa sequence of sentences, all involving the same verbform and each expressing a single message triple ofthe form 〈S, Pi, Oi〉, where S is the same in all thetriples and Pi are (unmodified) properties of the do-main ontology, a conjunction can be formed by men-tioning the subject and verb only once. 43

It has medium body. It has moderate flavor. ⇒ It has

medium body and moderate flavor.

The “and” is omitted when a preposition follows,as illustrated below. The particles of phrasal verbs(e.g., “shut down”) are not considered prepositions.

He was born in Athens. He was born in 1918.⇒ He was

born in Athens in 1918.

A similar rule applies to sentences produced fromdisjunctions of message triples, as illustrated below.A variant of the first rule, which avoids repeatingthe same head noun with multiple adjectives, is alsoapplied (if possible) to the resulting sentence.

The house wine has strong flavor or it has medium flavor.

⇒ The house wine has strong flavor or medium flavor.

⇒ The house wine has strong or medium flavor.

43Consult Harbusch and Kempen [73] for a broader treat-

ment of elliptical clausal coordinations.

Different verbs conjunction: When there is a se-quence of sentences, not involving the same verb,but each expressing a message triple of the form〈S, Pi, Oi〉, where S is the same in all the triples andPi are (unmodified) properties of the domain ontol-ogy, a conjunction can be formed, as shown below. 44

Bancroft Chardonnay is dry. It has moderate flavor. It

comes from Napa.⇒ Bancroft Chardonnay is dry, it has

moderate flavor, and it comes from Napa.

We discuss the generation of pronouns below. Thesubjects of the second, third etc. sentences aggre-gated by the rule above can be omitted, though theresult may sometimes sound less fluent.

A note on the limitations of the pipeline architectureBy operating on both message triples and ordered

sentence plans, Naturalowl’s aggregation rules con-sider not only the semantics of the sentences, butalso the particular text planning and lexicalizationchoices that have been made to express them. Forexample, the “same verb conjunction/disjunction”rule can be applied only to adjacent sentences in-volving the same verb, and the “class and preposi-tional phrase” rule can be applied only if the sec-ond sentence involves a prepositional phrase. Recallthat several sentence plans may apply to the samemessage triple, and they may involve different verbs,use of prepositional phrases vs. other phrasings etc.Hence, if aggregation took place before lexicalization[11,177], it would be impossible to decide if severalof the aggregation rules that we currently use couldbe applied or not, unless aggregation was more in-tertwined with lexicalization, allowing aggregationrules to select among alternative sentence plans.

With a broader perspective, if aggregation andlexicalization were both intertwined with contentselection and text planning, it might be possibleto select message triples not only with high inter-est scores, but also with sentence plans of high ap-propriateness that can be aggregated with manyother sentence plans; and aggregatable sentencescould be placed in adjacent positions to maximizeaggregation opportunities, while also attempting tomaximize local coherence. This would require, how-ever, replacing the pipeline architecture and its se-quential, in effect greedy, choices by an architecturewhere decisions pertaining to all the stages of nlgwould be considered in parallel [114,17]. Anotherpossibility would be to retain the pipeline, but allow

44Disjunctions of message triples give rise to a disjunction

of sentences without any need for further aggregation.

33

its modules to overgenarate by producing alterna-tives (e.g., several alternative sets of selected mes-sage triples, several alternative orderings of each setof message triples, several lexicalizations, aggrega-tions etc.) and rank the resulting texts at the end ofthe pipeline. 45 The latter approach, however, leadsto an exponentially large number of alternatives,when several modules are allowed to overgenerate.

2.2.3. Generating referring expressionsA sentence plan may require an appropriate re-

ferring expression to be generated for the S of an〈S, P,O〉 message triple, as already discussed. De-pending on the context, it may be better, for ex-ample, to use the nl name of S (e.g., “the Stoa ofZeus Eleutherios”), a pronoun (e.g., “it”), a demon-strative noun phrase (e.g., “this stoa”) etc. Simi-lar alternatives could be made available for O, butNaturalowl currently always uses O itself, if it is adatatype value; or the nl name of O, its tokenizedidentifier, or its rdfs:label, if O is an entity or class;and similarly for conjunctions and disjunctions inO.Hence, below we focus only on referring expressionsfor S. Adding mechanisms to generate more variedexpressions for O is a possible future extension.

Generating the most appropriate referring expres-sion is a complex problem. It involves consideringmultiple candidate referring expressions, whether ornot each candidate expression identifies a uniquereferent, how easily a hearer can understand eachexpression, the length of, or time to utter each ex-pression, the desire to avoid repeating the same ex-pressions etc. Krahmer and van Deemter [101] pro-vide an extensive survey of research on referring ex-pression generation. Naturalowl currently uses avery limited range of referring expressions, whichincludes only nl names (or tokenized identifiers orrdfs:label strings), pronouns, and noun phrases in-volving only a demonstrative and the nl name of aclass (e.g., “this vase”). For example, referring ex-pressions that mention properties of S (e.g., “thevase from Rome”) are not generated. 46 Although

45See, for example, Walker et al. [171] for a dialogue systemthat uses an overgenerate and rank approach to aggregation.46When generating comparisons, Naturalowl also produces

expressions referring to previously encountered individuals or

sets of individuals (e.g., “Unlike all the previous vessels thatyou have seen, this lekythos is decorated with the black-figure

technique”), and also some spatial referring expressions (e.g.,“Like the tetradrachm that you saw, which is now behindme, this drachma was found in Athens”) [85], but we do not

consider comparisons in this article.

Naturalowl’s current referring expression genera-tion mechanisms work reasonably well in the on-tologies we have experimented with, they are bestviewed as a placeholder for more elaborate algo-rithms [37,39,164,79,102,165,133,40], especially al-gorithms based on description logics [7,147], whichwe hope to see included in future versions. 47

To explain how referring expressions for S are cur-rently generated, let us consider the following text,which expresses the message triples below. We donot aggregate sentences in this section, to illustratemore cases where referring expressions are needed;note, however, that aggregation would reduce thenumber of pronouns, making the text less repetitive.

(1) Exhibit 7 is a statue. (2) It was sculpted by Nikolaou.

(3) Nikolaou was born in Athens. (4) He was born in 1918.(5) He died in 1998. • (6) Exhibit 7 is now in the National

Gallery. (7) It is in excellent condition.

<:exhibit7, instanceOf, :Statue>

<:exhibit7, :hasSculptor, :nikolaou>

<:nikolaou, :cityBorn, :athens>

<:nikolaou, :yearBorn,


<:nikolaou, :yearDied,


<:exhibit7, :currentLocation, :nationalGallery>

<:exhibit7, :currentCondition, :excellentCondition>

Recall that in a sentence un that Naturalowl gen-erates for a message triple 〈Sn, Pn, On〉, typicallyCf (un) = {Sn, On} and cp(un) = Sn, since Sn istypically realized as the most salient noun phrase ofun, usually the subject. As in Section 2.1.2, we showin italics the noun phrase realizing cp(un); we showunderlined the noun phrase realizing cb(un); and wemark nocb transitions with bullets.

Naturalowl pronominalizes Sn (for n > 1) onlyif Sn = Sn−1, as in sentences 2, 4, 5, and 7. Sincetypically cp(ui) = Si, we typically obtain cp(un) =cp(un−1), whenever Sn is pronominalized, if the pro-noun is resolved by the reader as intended. Whenreading a text, there is a tendency to prefer read-ings where cp(un) = cp(un−1), if no other restric-tion is violated (e.g., gender, number, case agree-ment, world knowledge constraints). This helps thepronouns that Naturalowl generates to be correctlyresolved by readers, even when they would appearto be potentially ambiguous. For example, the pro-noun of sentence 7 is most naturally understood asreferring to the exhibit, as it is intended to, not to

47See also Kibble and Power [92] for a ct-based method for

both text planning and choice of referring expressions.

34

the gallery, even though both the gallery and the ex-hibit are neuter and can be in excellent condition.Note that with both referents, the transition from(6) to (7) is a continue; hence, transition type pref-erences play no role.

The gender of each generated pronoun is the gen-der of the (most appropriate) nl name of the S thatthe pronoun realizes. 48 If S does not have an nlname, Naturalowl uses the gender of the (most ap-propriate) nl name of the most specific class that in-cludes S and has an nl name (or one of these classes,if they are many). If exhibit7 in our previous exam-ple does not have an nl name, i.e., “exhibit 7” is atokenized identifier or rdfs:label, if the most specificclass of exhibit7 is Exhibit, and if Exhibit has onlyone nl name in the target language and its genderis neuter, Naturalowl uses a neuter pronoun, as inthe example above. nl names can also be associ-ated with sets of genders, which give rise to pseudo-pronouns like “he/she”; this may be desirable, forexample, in the nl name of a class like Person.

With some individuals or classes, we may notwish to use nl names, nor tokenized identifiers norrdfs:label strings. This is common, for example,in museum ontologies, where some exhibits areknown by particular names (e.g., a classical statueknown as the “Doryphoros”), but many other ex-hibits are anonymous and their owl identifiers(e.g., exhibit317) are not particularly meaningful toend-users. Naturalowl allows the domain authorto mark individuals and classes as anonymous, toindicate that their nl names, tokenized identifiers,and rdfs:label strings should be avoided. Whenthe primary target (the individual or class the textis generated for) is marked as anonymous, Nat-uralowl uses a demonstrative noun phrase (e.g.,“this statue”) to refer to it. The demonstrativephrase involves the nl name of the most specificclass that subsumes the primary target, that has annl name, and has not been marked as anonymous(or one of these classes, if they are many). Especiallyin sentences that express isA or instanceOf messagetriples about the primary target, the demonstrativenoun phrase is simply “this”, to avoid generating

48Note that in languages like Greek, which use grammaticalinstead of natural genders, the pronouns’ genders cannot be

determined by consulting the domain ontology (e.g., to checkif the referent is animate or inanimate). For example, the

Greek nl names (nouns) for “computer” (“upologist c”),

“screen” (“ojình”), and “keyboard” (“plhktrolìgio”) aremasculine, feminine, and neuter, respectively, and pronouns

must be in the same gender as the corresponding nl names.

sentences like “This statue is a statue”. Assum-ing, for example, that exhibit7 has been marked asanonymous, that its most specific super-class thathas not been marked as anonymous is Statue, andthat Statue has the nl name “statue”, the text ofour previous example becomes as follows. 49

(1) This is a statue. (2) It was sculpted by Nikolaou. (3)Nikolaou was born in Athens. (4) He was born in 1918. (5)

He died in 1998. • (6) This statue is now in the National

Gallery. (7) It is in excellent condition.

The marking of anonymous individuals andclasses currently applies only to the primary target.For example, if the primary target is Nikolaou, thenthe generated text may still contain sentences like“Nikolaou sculpted exhibit 7 and exhibit 9”, even ifexhibit7 and exhibit9 have been marked as anony-mous. Although a sentence like “Nikolaou sculptedtwo statues” could easily be produced instead, com-plications arise if, for example, there is informationto be conveyed for both statues, in which case wewould need to produce appropriate referring expres-sions (e.g., “the first one”, “the second statue”).We leave such improvements for future work, alongwith work to produce more varied referring expres-sions for the Os of message triples (e.g., reflexivesin sentences like “He painted himself ”). 50

2.3. Surface realization

In many nlg systems, the sentences at the endof micro-planning are underspecified; for example,the exact order of their syntactic constituents orthe exact forms of their words (e.g., gender, num-ber, case) may still be unspecified. Generic surfacerealizers based on large-scale grammars or statisti-cal models can then be used to fill in the missinginformation during surface realization, as alreadydiscussed (Section 2.2.1). 51 By contrast, in Natu-ralowl (and most template-based nlg systems) thesentence plans at the end of micro-planning alreadycompletely specify the surface (final) form of eachsentence; recall that referring expressions will have

49 If a sentence about a parent class of the primary targethas been generated and the next sentence uses a demonstra-tive noun phrase to refer to the primary target, then thedemonstrative includes “particular” to signal more clearlythat the discussion has shifted back to the primary target;

see, for example, the generated text of page 18.50The tuna [62] and grec [18] challenges and their datasetscould be particularly useful in future improvements.51 ilex and m-piro used Systemic Grammars [71,15].

35

already been generated, and aggregation will havebeen performed. The order of the sentences will havealso been specified during text planning. Hence, Nat-uralowl’s surface realization is mostly a process ofconverting internal, but fully specified and orderedsentence specifications to the final form of the text.Punctuation is also added, the initial letter of eachsentence is capitalized etc.

Application-specific markup (e.g., html tags,hyperlinks) or images (e.g., of individuals beingdescribed) can also be added by modifying Natu-ralowl’s surface realization code. In project indigo,for example, where Naturalowl was embedded inrobots acting as a museum guides, surface realiza-tion was modified to include xml syntactic andsemantic markup. 52 There were, for instance, tagsthat marked sentences with high interest scores,leading the robot to use an emphasis voice and anappropriate facial expression. The sentences werealso marked up with the message triples they ex-pressed, to help a dialogue manager keep track ofthe information conveyed to each end-user.

3. Other related work

We have already provided pointers to relevantwork that could be used to enhance Naturalowl’sprocessing stages. We now turn to controlled natu-ral languages and ontology verbalizers for owl, andsubsequently to other nlg work for owl ontologies.

3.1. Controlled languages and verbalizers for OWL

As already noted, we have been using owl’sfunctional-style syntax, but several semanticallyequivalent owl syntaxes have been proposed. Therehas also been work to develop controlled naturallanguages (cnls), mostly English-like, to be usedas alternative owl syntaxes. For example, Syd-ney owl Syntax (sos) [36] is an English-like cnlwith a bidirectional mapping to and from owl’sfunctional-style syntax; sos is based on experi-

52 indigo was an fp6 ist project of the EuropeanUnion; consult http://www.ics.forth.gr/indigo/. Natu-ralowl’s Protege plug-in can optionally display the gen-

erated texts with indigo’s markup. In previous demon-strators, the generated texts included rdfa markup; see

http://www.w3.org/TR/xhtml-rdfa-primer/. In a similar

manner, schema.org markup could also be included by gen-erating texts from schema.org ontologies represented in

owl; consult http://www.schema.org/.

ence from peng [150,154]. A similar bidirectionalmapping has been defined for Attempto ControlledEnglish (ace) [58,84,83], a cnl originally devel-oped for software specifications. Rabbit [74,46] andclone [59] are other owl cnls, mostly intended tobe used by domain experts during ontology author-ing [47], i.e., when creating owl ontologies. Someowl cnls are only partial owl syntaxes, meaningthat they cannot express all the statements of otherowl syntaxes. Consult Schwitter et al. [153] forrelated discussion and a comparison of sos, ace,and Rabbit. Schwitter [151] provides a broaderintroduction to cnls for knowledge representation.

Much work on owl cnls focuses on ontology au-thoring and ontology querying [21,22,19,103,152,90];in both cases, the emphasis is mostly on the direc-tion from cnl to owl or formal query languages. 53

In Rabbit, for example, the main goal seems to be totranslate from cnl to a normative owl syntax, notbackwards. More relevant to this article are cnlslike sos and ace, to which automatic mappingsfrom normative owl syntaxes are available.

By feeding an owl ontology expressed, for ex-ample, in functional-style syntax to a mapping thattranslates to an English-like cnl, all the axioms ofthe ontology can be turned into English-like sen-tences. Systems of this kind are often called ontologyverbalizers, a term we introduced briefly in Section1. This term, however, also includes systems thattranslate from owl to English-like statements thatdo not necessarily belong in an explicitly definedcnl [78,69,149,141,137,157,158,109,110].

Although ontology verbalizers can be viewed asperforming a kind of light nlg, they are differentfrom Naturalowl and other similar, more complexnlg systems. As already discussed, verbalizers typi-cally translate axioms one by one, without consider-ing the coherence (or topical cohesion) of the result-ing texts, usually without aggregating sentences norgenerating referring expressions, and often by pro-ducing sentences that are not entirely fluent or natu-ral; for example, ace and sos occasionally use vari-ables instead of noun phrases and referring expres-sions [153]. Also, verbalizers typically do not employany user modeling mechanisms; for example, theydo not attempt to model the interests and linguisticpreferences (e.g., vocabulary, length of texts) of dif-

53The wysiwym approach or conceptual authoring [139,70],

which has recently been applied to owl ontologies [140,136],and round-trip authoring [161,59,44] are bidirectional, but

again they focus mostly on ontology authoring and querying.

36

ferent types of readers, nor the information that hasalready been conveyed to them (e.g., to avoid rep-etitions). Expressing the exact meaning of the on-tology’s axioms in an unambiguous manner is con-sidered more important in verbalizers than compos-ing a fluent, coherent, and interesting text, partlybecause the verbalizers’ texts are typically intendedto be read by domain experts during ontology au-thoring. Furthermore, verbalizers treat the domainontology as the only source of domain-dependentinformation, without employing additional domain-dependent generation resources.

3.2. NLG systems for OWL ontologies

We now consider more complex, compared to ver-balizers, nlg systems for owl ontologies. We notethat the distinction between the two types of sys-tems is not always clear. For example, some verbaliz-ers include basic sentence aggregation [177] and textplanning [109], and some of the systems we discussbelow attempt to extract domain-dependent linguis-tic resources from the domain ontology. Schutte’ssystem [149] is particularly difficult to classify, as italso generates pronouns and invokes kpml [15], oth-erwise being closer to verbalizers.

3.2.1. Ontosumontosum [25] generates natural language de-

scriptions of individuals, but apparently not classes,from rdf and owl ontologies. It is an extension ofmiakt [28,24], which was used to generate medi-cal reports. Both were implemented in gate [27].They provide graphical user interfaces to manipu-late domain-dependent generation resources, andthe domain ontologies can be edited with a versionof Protege embedded in gate [26].ontosum adopts a pipeline architecture, simi-

lar to Naturalowl’s. Content selection identifies thefacts to express, excluding facts that have been men-tioned. ontosum’s user modeling mechanisms ap-pear to be more limited than Naturalowl’s; for ex-ample, there do not seem to be mechanisms to spec-ify the interest of the domain ontology’s facts.

In text planning, ontosum uses text schemata(Section 2.1.2). For sentence planning, it providesbuilt-in sentence plans for four basic properties (e.g.,active-action, part-whole). Every other property ismade (manually or via heuristics that examine theproperties’ identifiers) a sub-property of a basic one,which allows it to inherit a sentence plan from a

basic property.ontosum can also express propertiesby using their rdfs:label strings, strings obtainedby tokenizing the properties’ identifiers, or stringsprovided by the domain author; the effect is similar,as when using Naturalowl’s default sentence plan.

Unlike Naturalowl, ontosum’s aggregation op-erates only on logical facts, before micro-planning,and it aggregates only facts involving the same se-mantic subject and property. Like Naturalowl, on-tosum maps classes and individuals to nl names,specified in a domain-dependent lexicon. onto-sum’s nl names, however, are simpler; for example,they do not mark head words, prepositions, etc.,information that is used in some of Naturalowl’saggregation rules. There are also mechanisms in on-tosum to extract nl names from rdfs:label stringsor identifiers, when lexicon entries are unavailable.

No detailed description of ontosum, at least notas detailed as this article, appears to have been pub-lished, and the system does not seem to be publiclyavailable, unlike Naturalowl. Furthermore, no tri-als of ontosum with independently created domainontologies seem to have been published.

3.2.2. Other NLG systems for OWL and RDF

Mellish and Sun [125,159,160] focus mostly onlexicalization and aggregation, aiming to producea single aggregated sentence from an input collec-tion of rdf triples; by contrast, Naturalowl pro-duces multi-sentence texts. In complementary work,Mellish et al. [124,121,122] also consider content se-lection in the generation of natural language de-scriptions of owl classes. Unlike Naturalowl, theirsystem does not select only facts that are explic-itly mentioned in the domain ontology, but it alsoconstructs facts that can be inferred from the do-main ontology by performing reasoning in descrip-tion logic. It would be particularly interesting to ex-amine how reasoning mechanisms of this kind couldbe added to Naturalowl’s content selection.

Wilcock’s nlg engine [174,175,176] has been usedto generate texts from rdf and daml+oil ontolo-gies, daml+oil being a predecessor of owl. 54 Weare not aware, however, of any attempts to use thatengine with owl ontologies.

54See http://www.w3.org/Submission/2001/12/.

37

4. Trials

In previous work, Naturalowl was used mostlyto describe cultural heritage objects. In project xe-nios, for example, it was tested with an owl ver-sion of a domain ontology that was created duringm-piro to document approximately 50 archaeologi-cal exhibits (e.g., statues, coins, vases) [4]. The owlversion comprised 76 classes, 343 individuals (in-cluding cities, persons, historical periods, etc.), and41 properties. In xenios, Naturalowl was also em-bedded in a robotic avatar that presented m-piro’sexhibits in a virtual world museum [131], and in areal-world mobile robot that provided informationabout a cultural heritage centre and its exhibitions[169]. 55 More recently, in project indigo [96,97],Naturalowl was embedded in mobile robots act-ing as tour guides in an exhibition about the an-cient Agora of Athens. The robots escorted visitorsto wall-mounted screens showing present day pho-tos and digital reconstructions of the Agora’s mon-uments. 56 An owl domain ontology documenting43 monuments was used; there were 49 classes, 494individuals, and 56 properties in total.

In the projects mentioned above, Naturalowl’stexts were eventually almost indistinguishable fromhuman-authored texts. We participated, however,along with curators and other colleagues, in the de-velopment of the domain ontologies, and we mayhave biased the domain ontologies towards choices(e.g., classes and properties) that made it easier forNaturalowl to generate high-quality texts. Hence,in the trials discussed below, we wanted to exper-iment with independently developed owl domainontologies. We also wanted to experiment with dif-ferent domains, as opposed to cultural heritage.

A further goal was to compare Naturalowl’s textsagainst those of a simpler verbalizer. We used theowl verbalizer of the swat project [158,178], whichwe found to be particularly robust and useful, as

55xenios was co-funded by the European Union and the

Greek General Secretariat of Research and Technology; seehttp://www.ics.forth.gr/xenios/.56Videos of the robotic guides of xenios and indigo in action

are available at http://nlp.cs.aueb.gr/projects.html.Two aueb students, George Karakatsiotis and Vangos

Pterneas won the Interoperability Challenge of Microsoft’s

Imagine Cup 2011 with a similar mobile phone applica-tion, called Touring Machine, that uses Naturalowl; see

http://www.youtube.com/watch?v=PaNAmNC7dZw. In Touring

Machine and indigo, the domain-dependent generation re-sources were also used to answer follow-up questions (e.g.,

about persons mentioned in descriptions of monuments).

it provides a quick English-like view of an owl do-main ontology with no domain authoring effort. 57

The verbalizer produces, among other outputs, analphabetical glossary with an entry for each namedclass, property, and individual. Each glossary entryis a sequence of English-like sentences expressingthe owl statements of the ontology that involve theparticular class, property, or individual.

The swat verbalizer uses a predetermined par-tial order of statements in each glossary entry; forexample, when describing a class, statements aboutequivalent classes or super-classes of the target classare mentioned first, and individuals belonging inthe target class are mentioned last. 58 The verbal-izer actually translates the owl ontology to Prolog,it extracts lexicon entries from owl identifiers andrdfs:label strings, and it uses predetermined sen-tence plans specified as a dcg grammar. It also ag-gregates, in effect, message triples of the same prop-erty that share one argument (S or O) [177].

Our hypothesis was that the domain-dependentgeneration resources would help Naturalowl pro-duce texts that end-users would consider morefluent, coherent, and interesting compared to thoseproduced by the swat verbalizer, but also those pro-duced by Naturalowl without domain-dependentgeneration resources. We also wanted to measurethe effort that is required to create Naturalowl’sdomain-dependent generation resources for exist-ing domain ontologies. This was not measured inour previous work, because the development ofthe domain-dependent generation resources wascombined with the development of the domainontologies. Since the time needed to create thedomain-dependent generation resources depends onone’s familiarity with Naturalowl and its Protegeplug-in, exact times are not particularly informa-tive. Instead, we report figures such as the numberof sentence plans, lexicon entries, user modelingannotations etc. that were required, along with ap-proximate times. We do not evaluate the usabilityof Naturalowl’s Protege plug-in, since it is very

57The swat verbalizer can be used on the Web athttp://swat.open.ac.uk/tools/. We used the version thatwas on-line in July and August 2011. A similar ver-balizer from owl to ace (Section 3.1) is available at

http://attempto.ifi.uzh.ch/site/docs/owl to ace.html.58The verbalizer also organizes the English-like sentences

of each glossary entry under sub-headings like ‘Definition’,‘Taxonomy’, ‘Description’, ‘Distinctions’ [178]. We discardedthese subheadings, whose meanings were not entirely clear

to us, but we retained the order of the sentences.

38

similar to m-piro’s authoring tool. Previous usabil-ity experiments [4] showed that computer sciencegraduates with no expertise in nlg could learn touse effectively m-piro’s authoring tool to create thenecessary domain-dependent generation resourcesfor existing or new domain ontologies, after receiv-ing the equivalent of a full-day introduction course.

4.1. Trials with the Wine Ontology

In the first trial, we experimented with the WineOntology, which is often used in Semantic Web tu-torials. 59 It comprises 63 wine classes (and sub-classes), 52 wine individuals, a total of 238 classesand individuals (including kinds of grapes, wineries,regions, etc.), and 14 properties.

We submitted the Wine Ontology to the swatverbalizer to obtain its glossary of English-like de-scriptions of classes, properties, and individuals. Weretained only the descriptions of the 63 wine classesand the 52 wine individuals. Subsequently, we alsodiscarded 20 of the 63 wine class descriptions, asthey were for trivial classes (e.g., RedWine) and theywere stating the obvious (e.g., “A red wine is de-fined as a wine that has as color Red”). In the de-scriptions of the remaining 43 wine classes and 52wine individuals, we discarded sentences expressingaxioms that Naturalowl does not consider, for ex-ample sentences providing examples of individualsthat belong in a class being described, or sentencesthat in effect express message triples of the form〈S, P,O〉 when the target is O (not S). The remain-ing texts express the same owl statements that Nat-uralowl expresses when its maximum fact distanceis set to one and no user modeling anotations areprovided. 60 Two examples of texts obtained by us-ing the swat verbalizer follow.

Chenin Blanc (class): A chenin blanc is defined as some-

thing that is a wine, is made from grape the Chenin

Blanc Grape, and is made from grape at most one thing.

A chenin blanc both has as flavor Moderate, and has as

color White. A chenin blanc both has as sugar only Off

Dry and Dry, and has as body only Full and Medium.

The Foxen Chenin Blanc (individual): The Foxen Chenin

Blanc is a chenin blanc. The Foxen Chenin Blanc has as

59See http://www.w3.org/TR/owl-guide/wine.rdf.60 In the verbalizer’s texts, we also discarded sentences ex-

pressing DifferentIndividuals statements, as they tendedto be particularly long and boring; these statements were

also discarded when generating Naturalowl’s texts.

body Full. The Foxen Chenin Blanc has as flavor Mod-

erate. The Foxen Chenin Blanc has as maker Foxen. The

Foxen Chenin Blanc has as sugar Dry. The Foxen Chenin

Blanc is located in the Santa Barbara Region.

We then generated texts for the 43 classes and 52individuals using Naturalowl without domain de-pendent generation resources, setting the maximumfact distance to one; example texts follow.

Chenin Blanc (class): Chenin Blanc is wine. Chenin Blanc

has body only Full or Medium. Chenin Blanc has sugar

only Off Dry or Dry. Chenin Blanc has color White.

Chenin Blanc has flavor Moderate. Chenin Blanc made

from grape exactly one Wine Grape: Chenin Blanc Grape.

The Foxen Chenin Blanc (individual): Foxen Chenin

Blanc is Chenin Blanc. Foxen Chenin Blanc has sugar

Dry. Foxen Chenin Blanc has maker Foxen. Foxen Chenin

Blanc has body Full. Foxen Chenin Blanc located in

Santa Barbara Region. Foxen Chenin Blanc has flavor

Moderate.

Subsequently, we constructed Naturalowl’sdomain-dependent generation resources for theWine Ontology. The resources are summarized inTable 10. They were constructed by the secondauthor, who devoted approximately three days totheir construction, testing, and refinement. OnlyEnglish texts were generated in this trial; hence, noresources for Greek were constructed. We definedonly one user type, and we added user modelingannotations only to block sentences stating the ob-vious, by assigning zero interest scores to the corre-sponding message triples; we also set the maximummessages per (aggregated) sentence to 3. Only 7 ofthe 14 properties of the Wine Ontology are usedin the owl statements that describe the 43 classesand 52 individuals. We defined 5 sentence plans,which could be used to express the 7 properties;some properties could be expressed by the samesentence plan (e.g., involving the verb “to be”),which is why there are only 5 sentence plans. Wedid not define multiple sentence plans per property.We also assigned the 7 properties to 2 sections,and we ordered the sections and their properties.We created nl names only when the automaticallyextracted ones were causing disfluencies. The au-tomatically extracted names were obtained fromthe owl identifiers of classes and individuals; nordfs:label strings were available. To reduce thenumber of nl names further, we declared the 52individual wines to be anonymous (and provided nonl names for them), which caused Naturalowl to

39

resources English Greek

sections 2

property assignments to sections 7

interest score assignments 8

sentence plans 5 −

lexicon entries 67 −

natural language names 41 −Table 10

Domain-dependent generation resources created for theWine Ontology (one user type).

use “this wine” in the first sentence of each wine’sdescription, instead of using the wine’s name. Mostof the 67 lexicon entries were used in the remaining41 nl names of classes and individuals (includingregions, wineries, kinds of grapes, etc.) that we hadto construct. Hence, most of the authoring effortwas devoted to nl names (see Table 10), despitethe actions we took to reduce their number; weinvestigate this issue further in the next trial. Wenote, however, that most of the nl names were verysimple, having only 2 slots on average.

We used Naturalowl with the domain-dependentresources to re-generate the 95 texts for the 43classes and 52 individuals, again setting the maxi-mum fact distance to one; example texts follow.

Chenin Blanc (class): A Chenin Blanc is a moderate, white

wine. It has only a full or medium body. It is only off-dry

or dry. It is made from exactly one wine grape variety:

Chenin Blanc grapes.

The Foxen Chenin Blanc (individual): This wine is a mod-

erate, dry Chenin Blanc. It has a full body. It is made by

Foxen in the Santa Barbara County.

The resulting 285 texts (95× 3) of the three sys-tems (swat verbalizer, Naturalowl with and with-out domain-dependent generation resources) wereshown to 10 computer science students (both un-dergraduates and graduate students), who were notinvolved in the development of Naturalowl; theywere all fluent in English, though not native Englishspeakers, and they did not consider themselves wineexperts. The students were told that a glossary ofwines was being developed for people who were in-terested in wines and knew basic wine terms (e.g.,wine colors, wine flavors), but who were otherwisenot wine experts. Each one of the 285 texts was givento exactly one student. Each student was given ap-proximately 30 texts, approximately 10 randomlyselected texts from each system. The owl state-

ments that the texts were generated from were notshown, and the students did not know which systemhad generated each text. Each student was shownall of his/her texts in random order, regardless ofthe system that had generated them. The studentswere asked to score the texts for sentence fluency,referring expressions, text structure, clarity, and in-terest, by stating for each text how strongly theyagreed or disagreed with statements S1–S5 below.A scale from 1 to 3 was used (1: disagreement, 2:ambivalent, 3: agreement).

(S1) Sentence fluency : The sentences of the textare fluent, i.e., each sentence on its own is grammat-ical and sounds natural. When two or more smallersentences are merged to form a single, longer sen-tence, the resulting longer sentence is also grammat-ical and sounds natural.

(S2) Referring expressions: The use of pronouns(e.g., “it”, “his”) and other referring expressions(e.g., “this wine”) in the text is appropriate. Thechoices of referring expressions (e.g., when to use apronoun or other expression instead of the name ofan object) sound natural, and it is easy to under-stand what these expressions stand for (e.g., whichobject a pronoun refers to).

(S3) Text structure: The order of the sentences isappropriate. The text presents information by mov-ing reasonably from one topic to another.

(S4) Clarity : The text is easy to understand, pro-vided that the reader is familiar with basic wineterms (e.g., wine colors, wine flavors).

(S5) Interest : People who are interested in wines,but who are not wine experts, would find the infor-mation of the text interesting. Furthermore, thereare no redundant sentences in the text (e.g., sen-tences stating the obvious). 61

We had to avoid nlg terminology in statementsS1–S5 as much as possible, to ensure that the stu-dents would be able to understand them. S5 assessescontent selection, the first processing stage; we ex-pected the differences across the three systems tobe very small, as they all reported the same infor-mation, with the exception of redundant sentencesblocked by using zero interest assignments in Nat-uralowl. S3 assesses text planning, the second pro-cessing stage; again we expected small differences,as many of the wines’ properties can be mentionedin any order, though there are some properties (e.g.,

61The students were instructed not to consider whether or

not additional information should have been included.

40

maker, location) that are most naturally reportedseparately from others (e.g., color, flavor, taste),which is why we used 2 sections in the domain-dependent generation resources. S1 assesses lexical-ization and aggregation; we decided not to use sep-arate statements for these two processing stages,since it might have been difficult for the students tounderstand exactly when aggregation takes place.S2 assesses referring expression generation. S4 doesnot correspond to a particular processing stage; itmeasures the overall perceived clarity of the texts.There was no statement for surface realization, asthis stage (as used in all three systems) had a rathertrivial effect on the texts.

Table 11 shows the average scores of the three sys-tems, with averages computed on the 95 texts of eachsystem, along with 95% confidence intervals (of sam-ple means). 62 As expected, the domain-dependentgeneration resources clearly help Naturalowl pro-duce more fluent sentences and much better refer-ring expressions, despite Naturalowl’s simplistic re-ferring expression generation techniques. The textstructure scores show that the assignment of the do-main ontology’s properties to sections and the order-ing of the sections and properties had a greater (pos-itive) impact on the perceived structure of the textsthan we expected, also indicating how important thecorresponding resources are. The highest score of theswat verbalizer was obtained in the clarity crite-rion, which agrees with our experience that one canusually understand what the texts of the swat ver-balizer mean, even if their sentences are often not en-tirely fluent, not particularly well ordered, and keeprepeating proper names. With domain-dependentresources, Naturalowl had the highest clarity score,but the difference from the swat verbalizer, whichhad the second highest score, is not statistically sig-nificant. 63 With domain-dependent generation re-sources, Naturalowl also obtained higher interestscores than the other two systems, with statisticallysignificant differences from both; these differences,

62 In a pilot study, we also measured the inter-annotator

agreement of two of the students on a sample of 30 texts (10from each system). The agreement was very high (samplePearson correlation r ≥ 0.91) in all five criteria. A similarpilot study was also performed in the next trial, again indi-

cating very high inter-annotator agreement.63When the confidence intervals of two systems do not over-

lap, the difference is statistically significant. When the in-tervals overlap, the difference may still be statistically sig-nificant; we performed paired two-tailed t-tests (α = 0.05)

in these cases to check for statistical significance.

criteria swat Naturalowl − Naturalowl +

sentence fluency 2.00 ± 0.15 1.76 ± 0.15 2.80 ± 0.10

ref. expressions 1.40 ± 0.13 1.15 ± 0.09 2.72 ± 0.13

text structure 2.15 ± 0.16 2.20 ± 0.16 2.94 ± 0.05

clarity 2.66 ± 0.13 2.55 ± 0.13 2.74 ± 0.11

interest 2.30 ± 0.15 2.14 ± 0.16 2.68 ± 0.12

Table 11Average results, with 95% confidence intervals, for English

texts generated from the Wine Ontology by the swat ver-

balizer and Naturalowl with (+) and without (−) domain-dependent generation resources. For each criterion, the best

scores are shown in bold; the confidence interval of the best

score is also shown in bold if it does not overlap with theconfidence intervals of the other scores of the criterion.

which are larger than we expected, can only be at-tributed to the zero interest score assignments of thedomain-dependent generation resources, which areused to block sentences stating the obvious, becauseotherwise all three systems report the same infor-mation. The swat verbalizer obtained higher scoresthan Naturalowl without domain-dependent gener-ation resources, with the text structure score beingthe only exception. Only the difference in the refer-ring expression scores of the two systems, though, isstatistically significant. Both systems, however, re-ceived particularly low scores for their referring ex-pressions, which is not surprising, given that theyboth refer to individuals and classes by always usingautomatically extracted names; the slightly higherscore of the swat verbalizer is probably due to bettertokenization of the automatically extracted names.

4.2. Trials with the Consumer Electronics Ontology

In the second trial, we experimented with theConsumer Electronics Ontology, an owl ontologyfor consumer electronics products and services. 64

The ontology comprises 54 classes and 441 indi-viduals (e.g., printer types, paper sizes, well-knownmanufacturers), but no information about particu-lar products. We added 60 individuals describing 20digital cameras, 20 camcorders, and 20 printers. The60 individuals were randomly selected from a pub-licly available dataset of 286 digital cameras, 613

64Consult http://www.ebusiness-unibw.org/ontologies/

consumerelectronics/v1. The Consumer Electronics Ontol-ogy uses some concepts of the Good Relations Ontology; see

http://www.heppnetz.de/projects/goodrelations/.

41

camcorders, and 58 printers, whose instances com-ply with the Consumer Electronics Ontology. 65

We submitted the Consumer Electronics Ontol-ogy with the additional 60 individuals to the swatverbalizer, and we retained only the descriptionsof the 60 individuals. As in the previous trial, weremoved sentences expressing axioms that Natu-ralowl does not consider. We also shortened somesentences to remove parts expressing very general-level information (e.g., “Olympus E-520 is a prod-uct or service model, and a digital camera” became“Olympus E-520 is a digital camera”). Lastly, werenamed the string values of some datatype prop-erties to make the texts easier to understand (e.g.,the measurement unit “cmt” became “cm”). Anexample of a resulting description follows. Theowl identifiers of a few individuals are in German,which is why the sentence about the energy sourcementions “Akku”, which is “battery” in German.

The Sony Cyber-shot DSC-T90 is a digital camera.

The Sony Cyber-shot DSC-T90 has as manufacturer Sony.

The Sony Cyber-shot DSC-T90 has as data interface

type Usb2 0.

The Sony Cyber-shot DSC-T90 has as depth Depth.

Depth has as unit of measurement cm.

Depth has as value float 9.4.

The Sony Cyber-shot DSC-T90 has as digital zoom fac-

tor the Digital Zoom Factor.

The Digital Zoom Factor has as value float 12.1.

The Sony Cyber-shot DSC-T90 has as display size Dis-

play.

Display has as unit of measurement in.

Display has as value float 3.0.

The Sony Cyber-shot DSC-T90 has as energy source

Akku.

The Sony Cyber-shot DSC-T90 has as feature Video

Recording, Microphone and the Automatic Picture Sta-

bilizer.

The Sony Cyber-shot DSC-T90 has as focus size Focus

Size.

Focus Size has as max value float 140.0.

Focus Size has as min value float 35.0.

The Sony Cyber-shot DSC-T90 has as height Height.

Height has as unit of measurement cm.

Height has as value float 5.7.

The Sony Cyber-shot DSC-T90 has as internal memory

capacity the Internal Memory Capacity.

The Internal Memory Capacity has as unit of measure-

65See http://rdf4ecommerce.esolda.com/ for the datasetthat we used. A list of similar datasets is available at

http://wiki.goodrelations-vocabulary.org/Datasets.

ment GB.

The Internal Memory Capacity has as value float 11.0.

The Sony Cyber-shot DSC-T90 has as optical zoom fac-

tor Optical Zoom.

Optical Zoom has as value float 4.0.

The Sony Cyber-shot DSC-T90 has as shutter lag Shut-

ter Lag.

Shutter Lag has as max value float 0.0010.

Shutter Lag has as min value float 2.0.

Shutter Lag has as unit of measurement sec.

The Sony Cyber-shot DSC-T90 has as weight Weight.

Weight has as unit of measurement grm.

Weight has as value float 128.0.

The Sony Cyber-shot DSC-T90 has as width Width.

Width has as unit of measurement cm.

Width has as value float 1.5.

The Sony Cyber-shot DSC-T90 has as compact flash false.

The Sony Cyber-shot DSC-T90 has as dimension 9.4 x

1.5 x 5.7.

The Sony Cyber-shot DSC-T90 has as tv connector true.

The Sony Cyber-shot DSC-T90 has as self timer true.

In this domain ontology, many properties havecomposite values, which are expressed by using aux-iliary individuals. In the example above, a prop-erty (hasDepth) connects the digital camera being de-scribed to an auxiliary individual Depth (similar tothe anonymous node :n of the property concatena-tion price example of page 24), which is then con-nected via two other properties (hasValueFloat andhasUnitOfMeasurement) to the float value 9.4 and theunit of measurement (centimeters), respectively. Toimprove readability, we obtained the descriptions ofthe auxiliary individuals (e.g., Depth), which are en-tirely different entries in the glossary that the swatverbalizer produces, and we copied them immedi-ately after the corresponding sentences that intro-duce the auxiliary individuals. 66 We also formattedeach text as a list of sentences, with the copied sen-tences shown indented, again to improve readability.

We then generated texts for the 60 products by us-ing Naturalowl without domain-dependent genera-tion resources, setting the maximum fact distance toone. Descriptions of auxiliary individuals were alsogenerated, and they were copied immediately afterthe sentences introducing the auxiliary individuals,as with the texts of the swat verbalizer. The textswere again formatted as lists of sentences, with thesentences about the auxiliary individuals shown in-dented. An example of a resulting text follows.

66We also discarded sentences stating the datatypes of auxil-

iary individuals (e.g., “Depth is a quantitative value float”).

42

Sony Cyber-shot DSC-T90 is Digital Camera.

Sony Cyber-shot DSC-T90 has manufacturer Sony.

Sony Cyber-shot DSC-T90 has feature Automatic Pic-

ture Stabilizer, Microphone and Video Recording.

Sony Cyber-shot DSC-T90 has weight Weight.

Weight has unit of measurement grm.

Weight has value float 128.0.

Sony Cyber-shot DSC-T90 has energy source Akku.

Sony Cyber-shot DSC-T90 has display size Display.

Display has unit of measurement in.

Display has value float 3.0.

Sony Cyber-shot DSC-T90 has optical zoom factor Opti-

cal Zoom.

Optical Zoom has value float 4.0.

Sony Cyber-shot DSC-T90 has width Width.

Width has unit of measurement cm.

Width has value float 1.5.

Sony Cyber-shot DSC-T90 has shutter lag Shutter Lag.

Shutter Lag has min value float 2.0.

Shutter Lag has max value float 0.0010.

Shutter Lag has unit of measurement sec.

Sony Cyber-shot DSC-T90 has height Height.

Height has unit of measurement cm.

Height has value float 5.7.

Sony Cyber-shot DSC-T90 has internal memory capacity

Internal Memory Capacity.

Internal Memory Capacity has unit of measurement

GB.

Internal Memory Capacity has value float 11.0.

Sony Cyber-shot DSC-T90 has focus size Focus Size.

Focus Size has min value float 35.0.

Focus Size has max value float 140.0.

Sony Cyber-shot DSC-T90 has digital zoom factor Digi-

tal Zoom Factor.

Digital Zoom Factor has value float 12.1.

Sony Cyber-shot DSC-T90 has data interface type USB

2.0.

Sony Cyber-shot DSC-T90 has depth Depth.

Depth has unit of measurement cm.

Depth has value float 9.4.

Sony Cyber-shot DSC-T90 has self timer true.

In this trial, we also wanted to consider a scenariowhere there are many individuals to be described(e.g., products sold by a reseller), the set of individ-uals to be described changes frequently (e.g., newproducts arrive) along with other individuals (e.g.,a new manufacturer may be added), but nothingelse in the domain ontology changes (e.g., the def-initions of the classes, the available properties); inother words, only the assertional knowledge (ABox)

changes. In this case, it may be impractical to updatethe domain-dependent generation resources when-ever the individuals of the domain ontology change.Such an update might, for example, add particularuser modeling annotations about the new individu-als (e.g., to avoid saying that “The Sony Cyber-shotdsc-t90 is manufactured by Sony”), it might fine-tune the sentence plans to express more fluently in-formation about the new individuals, but most im-portantly it could provide nl names for the new in-dividuals; recall that the construction of nl namesmay be a significant part of the authoring effort.

Our hypothesis was that by considering a sampleof individuals of the types to be described (a sampleof cameras, camcorders, and printers in our case),it would be possible to construct domain-dependentgeneration resources (e.g., sections, ordering of sec-tions and properties, sentence plans, nl names ofclasses) that would help Naturalowl generate rea-sonably good descriptions of new individuals (prod-ucts), without updating the domain-dependent gen-eration resources, and by using the tokenized owlidentifiers or rdfs:label strings of new individuals,for which nl names would be unavailable.

To simulate a scenario of this kind, we randomlysplit the 60 products in two non-overlapping sets,the development set and the test set, each consistingof 10 digital cameras, 10 camcorders, and 10 print-ers. As in the previous trial, the second author con-structed and refined Naturalowl’s domain depen-dent generation resources, this time by consideringa version of the domain ontology that included the30 products of the development set, but not the 30products of the test set, and the texts generated forthe products of the development set; this took ap-proximately six days (for two languages). Texts forthe 30 products of the test set were then also gener-ated by using Naturalowl and the domain depen-dent generation resources of the development set.

As in the previous trial, we defined only one usertype, and we added user modeling annotations onlyto block sentences stating the obvious. The maxi-mum messages per (aggregated) sentence was againset to three. We constructed domain-dependent gen-eration resources for both English and Greek in thistrial; the resources are summarized in Table 12. Wecreated sentence plans only for the 42 properties ofthe domain ontology that were used in the develop-ment set (one sentence plan per property); the testset uses two additional properties, for which Nat-uralowl’s default sentence plans (for English andGreek) were used. We also assigned the 42 proper-

43

resources English Greek

sections 6

property assignments to sections 42

interest score assignments 12

sentence plans 42 42

lexicon entries 19 19

natural language names 36 36

Table 12

Domain-dependent generation resources created for theConsmer Electronics Ontology (one user type).

ties to 5 sections, and we ordered the sections andtheir properties. We created nl names only whenthe automatically extracted ones were causing dis-fluencies in the development texts. Unlike the previ-ous trial, the products to be described were not de-clared to be anonymous individuals, but the numberof nl names that had to be provided was roughlythe same as in the previous trial, since fewer au-tomatically extracted names were causing disfluen-cies; in particular, all product names had reason-ably good rdfs:label strings providing their Englishnames. The largest part of the authoring effort wasnow devoted to sentence plans, which was partly dueto the larger number of properties of the domain on-tology, compared to the previous trial.

An example description of a product from the de-velopment set produced by using Naturalowl withthe domain-dependent generation resources follows.We formatted the sentences of each section as a sep-arate paragraph, headed by the name of the section(e.g., “Other features:”); this formatting can be eas-ily achieved, given that sections can be automati-cally marked up by Naturalowl in the generatedtexts. The maximum fact distance was again set toone, but the sentence plans caused Naturalowl toautomatically retrieve additional message triples de-scribing the auxiliary individuals at distance one;hence, we did not have to retrieve this informa-tion manually, unlike the indented sentences in thetexts of the swat verbalizer and Naturalowl with-out domain-dependent generation resources. 67

Type: Sony Cyber-shot DSC-T90 is a digital camera.

Main features: It has a focal length range of 35.0 to

140.0 mm, a shutter lag of 2.0 to 0.0010 sec and an op-

tical zoom factor of 4.0. It has a digital zoom factor of

12.1 and its display has a diagonal of 3.0 in.

Other features: It features an automatic picture sta-

67See also the relevant footnote on page 24.

bilizer, a microphone, video recording and it has a self-

timer.

Energy and environment: It uses batteries.

Connectivity, compatibility, memory: It supports

USB 2.0 connections for data exchange and it has an

internal memory of 11.0 GB.

Dimensions and weight: It is 5.7 cm high, 1.5 cm wide

and 9.4 cm deep. It weighs 128.0 grm.

An example product description from the test setfollows. “Super A 3 B” is an automatically obtainedname (of a type of paper) that has been extractedfrom the corresponding owl identifier.

Type: Canon PIXMA Pro9500 is a printer.

Main features: Its maximum black and white printing

resolution is 4800.0 dots horizontally, 2400.0 dots verti-

cally and it prints on at most Super A 3 B. It holds up

to 150.0 sheets in the output tray.

Other features: It features color printing.

Energy and environment: It consumes 20.0 watt dur-

ing use, 1.8 watt during standby and its sound emission

is 34.0 db during use.

Connectivity, compatibility, memory: It does not

have network ability, it supports the PictBridge stan-

dard, USB 2.0 connections for data exchange, and it is

compatible with Mac OS X and Windows.

Dimensions and weight: It is 19.1 cm high, 35.4 cm

wide and 66.0 cm deep. It weighs 14000.0 grm.

It has max color print speed normal Max Color Print

Speed Normal.

The last sentence of the product description aboveexpresses a message triple involving a property(hasMaxColorPrintSpeedNormal) of the domain ontol-ogy for which no sentence plan has been provided,because that property was not used in the devel-opment set. The default sentence plan has beenused, but the O of the 〈S, P,O〉 message triple re-ported by the sentence is the auxiliary individualMaxColorPrintSpeedNormal. A manually crafted sen-tence plan would instruct Naturalowl to use thevalue of another property of the domain ontologythat leads from MaxColorPrintSpeedNormal to a nu-merical value expressing the printing speed (andsimilarly for the unit of measurement), and use thatnumber (and unit) as the object of the sentence.The default sentence plan, however, instructs Natu-ralowl to use the name of MaxColorPrintSpeedNormal

itself as the object, leading to a nonsensical sen-tence, where a tokenized form of the owl identi-fier MaxColorPrintSpeedNormal is used as the object.

44

Also, the sentence has been placed at the end ofthe text, because the property it expresses has notbeen assigned to any section. Problematic sentenceslike this were very rare in the texts that Natu-ralowl generated for the test set using the domain-dependent generation resources of the developmentset, because the two additional properties of thetest set were very rarely used. We also note thatin the scenario that we are mostly interested in,only the individuals of the domain ontology wouldchange; no new properties would be added, unlikethe two additional properties of this trial’s test set.

The 180 English texts that were generated by thethree systems for the 30 development and the 30 testproducts were shown to the same 10 students of thefirst trial. The students were now told that the textswould be used in on-line descriptions of products inthe Web site of a retailer, that the customers wouldalso be able to see information about the productsin the form of tables, but that the purpose of thestudy was to consider only the texts. Again, the owlstatements that the texts were generated from werenot shown to the students, and the students did notknow which system had generated each text. Eachstudent was shown 18 randomly selected texts, 9for products of the development set (three texts persystem) and 9 for products of the test set (againthree texts per system). Each student was shown allof his/her texts in random order, regardless of thesystem that had generated them. The students wereasked to score the texts as in the previous trial.

Table 13 shows the results for the English texts ofthe development set; when a confidence interval isshown as 0.00, this means that all the students gavethe same score to all the texts of that particular sys-tem. As in the previous trial, the domain-dependentgeneration resources clearly help Naturalowl pro-duce much more fluent sentences, and much betterreferring expressions and sentence orderings. Thetext structure scores of the swat verbalizer and Nat-uralowl without domain-dependent generation re-sources are now much lower than in the previoustrial, because the texts of these systems jump fromone topic to another making the texts look very in-coherent (e.g., a sentence that expresses the width ofa camera may be separated from a sentence express-ing its height by an intervening sentence about itsshutter lag), especially in this trial where the texts ofthe two systems are much longer. This incoherencemay have also contributed to the much lower clarityscores of these two systems, compared to the previ-ous trial. The interest scores of the two systems are



ref. expressions 1.10 ± 0.06 1.10 ± 0.11 2.87 ± 0.08

text structure 1.67 ± 0.15 1.33 ± 0.19 2.97 ± 0.04

clarity 1.97 ± 0.15 2.07 ± 0.26 3.00 ± 0.00

interest 1.77 ± 0.14 1.73 ± 0.29 3.00 ± 0.00


texts generated from development data of the Consumer

Electronics Ontology. The texts were generated by theswat verbalizer and Naturalowl with (+) and without (−)

domain-dependent generation resources. For each criterion,

the best scores are shown in bold; the confidence interval ofthe best score is also shown in bold if it does not overlap with

the confidence intervals of the other scores of the criterion.

also much lower than in the previous trial; this maybe due to the verbosity of their texts, which is causedby their frequent references to auxiliary individu-als in the second trial, combined with the lack (orvery little use) of sentence aggregation and pronoungeneration. By contrast, the clarity and interest ofNaturalowl with domain-dependent generation re-sources were judged to be perfect; the poor clarityand interest of the texts of the other two systemsmay have contributed to these perfect scores though.Again, the swat verbalizer obtained slightly betterscores than Naturalowl without domain-dependentgeneration resources, except for clarity, but the dif-ferences in the scores of the two systems are not sta-tistically significant in any of the criteria.

Table 14 shows the results for the English texts ofthe test set. The results of the swat verbalizer andNaturalowl without domain-dependent generationresources are very similar to those of Table 13, asone would expect. There was only a very marginaldecrease in the scores of Naturalowl with domain-dependent generation resources, compared to thescores of the same system for the development set(cf. Table 13). There is no statistically significantdifference, however, between the corresponding cellsof the two tables, for any of the three systems. Theseresults support our hypothesis that by consideringa sample of individuals of the types to be describedone can construct domain-dependent generation re-sources that can be used to produce good texts fornew individuals of the same types, provided that therest of the domain ontology remains unchanged. Thefact that all product names (but not other individ-uals) had rdfs:label strings providing their Englishnames probably contributed to the high results ofNaturalowl with domain-dependent generation re-

45



ref. expressions 1.10 ± 0.06 1.10 ± 0.06 2.87 ± 0.08

text structure 1.57 ± 0.13 1.37 ± 0.12 2.93 ± 0.05

clarity 2.07 ± 0.15 1.93 ± 0.15 2.97 ± 0.04

interest 1.83 ± 0.17 1.60 ± 0.14 2.97 ± 0.04


texts from test data of the Consumer Electronics Ontol-

ogy. The texts were generated by the swat verbalizer andNaturalowl with (+) and without (−) domain-dependent

generation resources. For each criterion, the best scores are

shown in bold; the confidence interval of the best score isalso shown in bold if it does not overlap with the confidence

intervals of the other scores of the criterion.

sources in the test set, but rdfs:label strings of thiskind are common in owl ontologies.

We then showed the 60 Greek texts that were gen-erated by Naturalowl with domain-dependent gen-eration resources to the same 10 students, who werenative Greek speakers; the swat verbalizer and Nat-uralowl without domain-dependent generation re-sources cannot generate Greek texts from the Con-sumer Electronics ontology. Table 15 shows the re-sults we obtained for the Greek texts of the develop-ment and test sets. There is no statistically signif-icant difference from the corresponding results forEnglish (cf. the last columns of Tables 13 and 14).There is also no statistically significant difference inthe results for the Greek texts of the developmentand test sets (Table 15). We note, however, that it iscommon to use English names of consumer electron-ics products in Greek texts, which made using theEnglish rdfs:label names of the products in Greektexts look acceptable. In other domains, for exam-ple about cultural heritage, it would be unaccept-able to use English names of monuments, locationsetc. in Greek texts; hence, one would have to pro-vide Greek nl names for any new individuals addedto the domain ontology.

5. Conclusions and future work

This article has provided a detailed description ofNaturalowl, an open-source nlg system that pro-duces texts (in English and Greek) describing in-dividuals or classes from owl domain ontologiesoptionally associated with domain-dependent gen-eration resources. Unlike simpler owl verbalizers,which typically express a single axiom of the do-

Naturalowl +, Naturalowl +,

criteria development data test data

sentence fluency 2.87 ± 0.12 2.83 ± 0.09

ref. expressions 2.77 ± 0.20 2.80 ± 0.11

text structure 3.00 ± 0.00 3.00 ± 0.00

clarity 3.00 ± 0.00 2.93 ± 0.05

interest 2.97 ± 0.06 3.00 ± 0.00

Table 15Avg. results, with 95% confidence intervals, for Greek texts

generated from development and test data of the Con-

sumer Electronics Ontology by Naturalowl with (+)and without (−) domain-dependent generation resources.

main ontology at a time in controlled and often notentirely fluent natural language mostly for the ben-efit of domain experts, Naturalowl aims to gener-ate fluent, coherent, and interesting multi-sentencetexts appropriate for end-users.

We discussed Naturalowl’s processing stages, theoptional domain-dependent generation resources ofeach stage, why the resources are useful, and howthey can also be represented in owl. We also pre-sented trials we performed to measure the effortthat is required to configure Naturalowl for newdomain ontologies, and the quality of the resultingtexts. The trials confirmed our hypothesis that thedomain-dependent generation resources help Natu-ralowl produce texts of significantly better qual-ity, compared to the texts produced without thedomain-dependent generation resources, and clearlybetter than the texts of a simpler owl verbalizer.

To the best of our knowledge, this is the firstdetailed description of a complete, general-purpose,nlg system for owl domain ontologies. It is alsothe first study of the effect of domain-dependentgeneration resources on the texts of a system thatcan describe owl classes and individuals bothwith and without domain-dependent generation re-sources. This article has also shown how the domain-dependent generation resources of Naturalowl canthemselves be represented in owl, which allowseasily publishing them on the Web, reusing them,checking them for inconsistencies etc., as with otherowl ontologies. The trials that we performed arealso novel, in that they considered existing owl do-main ontologies, created independently by others.

Naturalowl was partly developed to demonstratethe benefits of using nlg on the Semantic Web. Akey benefit is that it becomes possible to publish in-formation on the Web in the form of owl domainontologies, and rely on nlg to automatically pro-

46

duce personalized texts in multiple languages fromthe ontologies, thus making the information easilyaccessible not only to computer programs and do-main experts, but also end-users. We hope that Nat-uralowl will contribute towards a wider adoptionof nlg on the Semantic Web and also towards agradual standardization of domain-dependent gen-eration resources, allowing resources to be reusedmore easily across nlg systems. We welcome co-operations to add to Naturalowl support for ad-ditional languages and more eleborate nlg compo-nents. To that end we have suggested several pos-sible extensions, along with pointers to prominentrelated work, and we provide a collaborative sourcecode repository for Naturalowl.

We are currently working towards a global op-timization nlg approach, in order to replace thepipeline architecture of Naturalowl with an archi-tecture that will consider all the nlg processingstages in parallel, in order to avoid greedy stage-specific decisions. It would also be particularly inter-esting to explore how some of the domain-dependentgeneration resources could be obtained automati-cally from appropriate corpora.

References

[1] E. Althaus, N. Karamanis, A. Koller, Computing

locally coherent discourses, in: 42nd Annual Meeting

of ACL, Barcelona, Spain, 2004.[2] I. Androutsopoulos, S. Kallonis, V. Karkaletsis,

Exploiting OWL ontologies in the multilingualgeneration of object descriptions, in: 10th European

Workshop on NLG, Aberdeen, UK, 2005.[3] I. Androutsopoulos, P. Malakasiotis, A survey of

paraphrasing and textual entailment methods, Journal

of Artificial Intelligence Research 38 (2010) 135–187.[4] I. Androutsopoulos, J. Oberlander, V. Karkaletsis,

Source authoring for multilingual generation of

personalised object descriptions, Nat. LanguageEngineering 13 (3) (2007) 191–233.

[5] G. Angeli, P. Liang, D. Klein, A simple domain-independent probabilistic approach to generation,

in: Conf. on Empirical Methods in Nat. Language

Processing, Cambridge, MA, 2010.[6] G. Antoniou, F. van Harmelen, A Semantic Web

primer, 2nd ed., MIT Press, 2008.[7] C. Areces, A. Koller, K. Striegnitz, Referring

expressions as formulas of description logic, in: 5th Int.

Nat. Lang. Generation Conf. Salt Fork, OH, 2008.[8] F. Baader, D. Calvanese, D. McGuinness, D. Nardi,

P. Patel-Schneider (eds.), The description logichandbook: theory, implementation and application,

Cambridge University Press, 2002.[9] R. Barzilay, N. Elhadad, K. McKeown, Inferring

strategies for sentence ordering in multidocument

news summarization, Journal of Artificial IntelligenceResearch 17 (2002) 35–55.

[10] R. Barzilay, M. Lapata, Collective content selection

for concept-to-text generation, in: Human Lang.Technology Conf. and Conf. on Empirical Methods

in Nat. Language Processing, Vancouver, British

Columbia, Canada, 2005.

[11] R. Barzilay, M. Lapata, Aggregation via setpartitioning for natural language generation, in:

Human Lang. Technology Conf. of the North AmericanChapter of ACL, New York, NY, 2006.

[12] R. Barzilay, M. Lapata, Modeling local coherence:

An entity-based approach, Comput. Linguistics 34 (1)

(2008) 1–34.

[13] R. Barzilay, L. Lee, Catching the drift: Probabilistic

content models, with applications to generation and

summarization, in: 43rd Annual Meeting of ACL, AnnArbor, MI, 2004.

[14] J. Bateman, Upper modelling: A general organisation

of knowledge for nat. lang. processing, in: 5th Int.

Workshop on NLG, Dawson, PA, 1990.

[15] J. Bateman, Enabling technology for multilingual nat.

lang. generation: the KPML development environment,

Nat. Lang. Engineering 3 (1) (1997) 15–56.

[16] J. Bateman, M. Zock, Natural language generation, in:

R. Mitkov (ed.), The Oxford Handbook of Comput.

Linguistics, chap. 15, Oxford University Press, 2003,pp. 284–304.

[17] A. Belz, Automatic generation of weather forecast

texts using comprehensive probabilistic generation-

space models, Nat. Lang. Eng. 14 (4) (2008) 431–455.

[18] A. Belz, E. Kow, J. Viethen, A. Gatt, Generating

referring expressions in context: the GREC task

evaluation challenges, in: E. Krahmer, M. Theune(eds.), Empirical Methods in Nat. Lang. Generation,

Springer-Verlag, 2010, pp. 294–327.

[19] R. Bernardi, D. Calvanese, C. Thorne, Lite naturallanguage, in: 7th Int. Workshop on Comput. Semantics,

Tilburg, The Netherlands, 2007.

[20] T. Berners-Lee, J. Hendler, O. Lassila, The Semantic

Web, Scientific American (2001) 34–43.

[21] A. Bernstein, E. Kaufmann, GINO – a guided input

natural language ontology editor, in: 5th Int. Semantic

Web Conf. Athens, GA, 2006.

[22] A. Bernstein, E. Kaufmann, C. Kaiser, C. Kiefer,Ginseng: A guided input natural language search

engine for querying ontologies, in: Jena User Conf.Bristol, UK, 2006.

[23] D. Bilidas, M. Theologou, V. Karkaletsis, Enriching

OWL ontologies with linguistic and user-related

annotations: the ELEON system, in: 19th IEEE Int.Conf. on Tools with Artificial Intelligence, vol. 2,Patras, Greece, 2007.

[24] K. Bontcheva, Open-source tools for creation,maintenance, and storage of lexical resources for lang.generation from ontologies, in: 4th Conf. on Lang.

Resources and Evaluation, Lisbon, Portugal, 2004.

[25] K. Bontcheva, Generating tailored textual summariesfrom ontologies, in: 2nd European Semantic Web Conf.

Heraklion, Greece, 2005.

[26] K. Bontcheva, H. Cunningham, The Semantic Web:a new opportunity and challenge for human language

47

technology, in: Workshop on Human Lang. Technology

for the Semantic Web and Web Services, 2nd Int.

Semantic Web Conf. Sanibel Island, FL, 2003.

[27] K. Bontcheva, V. Tablan, D. Maynard, H. Cun-ningham, Evolving GATE to meet new challenges

in language engineering, Nat. Language Engineering10 (3/4) (2004) 349–373.

[28] K. Bontcheva, Y. Wilks, Automatic report generation

from ontologies: the MIAKT approach, in: 9th Int.

Conf. on Applications of Nat. Language to InformationSystems, Manchester, UK, 2004.

[29] S. Brin, L. Page, The anatomy of a large-scale

hypertextual Web search engine, Computer Networksand ISDN Systems 30 (1-7) (1998) 107–117.

[30] C. Brun, M. Dyteman, V. Lux, Document structure

and multilingual authoring, in: 1st Int. Nat. Lang.Generation Conf. Mitzpe Ramon, Israel, 2000.

[31] S. Busemann, H. Horacek, A flexible shallow approach

to text generation, in: 9th Int. Workshop on Nat. Lang.

Generation, New Brunswick, NJ, 1999.

[32] H. Chen, S. Branavan, R. Barzilay, D. Karger,

Content modeling using latent permutations, Journal

of Artificial Intelligence Research 36 (2009) 129–163.

[33] H. Cheng, C. Mellish, Capturing the interactionbetween aggregation and text planning in two

generation systems, in: 1st Int. Conf. on Nat. Lang.

Generation, Mitzpe Ramon, Israel, 2000.

[34] P. Cimiano, P. Buitelaar, J. McCrae, M. Sintek,

LexInfo: A declarative model for the lexicon-ontology

interface, Web Semantics 9 (1) (2011) 29–51.

[35] H. Clark, Bridging, in: P. Johnson-Laird, P. Wason(eds.), Thinking: Readings in Cognitive Science,

Cambridge University Press, 1977, pp. 9–27.

[36] A. Cregan, R. Schwitter, T. Meyer, Sydney OWLsyntax – towards a controlled natural language syntax

for OWL 1.1, in: OWL Experiences and Directions

Workshop, Innsbruck, Austria, 2007.

[37] R. Dale, Generating Referring Expressions: Con-

structing Descriptions in a Domain of Objects and

Processes, MIT Press, 1992.

[38] R. Dale, S. Green, M. Milosavljevic, C. Paris,C. Verspoor, S. Williams, Dynamic document delivery:

generating natural language texts on demand, in: 9thInt. Conf. and Workshop on Database and Expert

Systems Applications, Vienna, Austria, 1998.

[39] R. Dale, E. Reiter, Computational interpretations of

the Gricean maxims in the generation of referringexpressions, Cognitive Science 18 (1995) 233–263.

[40] R. Dale, J. Viethen, Attribute-centric referring

expression generation, in: E. Krahmer, M. Theune(eds.), Empirical Methods in Nat. Lang. Generation,

Springer, 2010, pp. 163–179.

[41] H. Dalianis, Aggregation in nat. lang. generation,Comput. Intelligence 15 (4) (1999) 384–414.

[42] D. Dannells, Applying semantic frame theory toautomate natural language template generation from

ontology statements, in: 6th Int. Nat. Lang. GenerationConf. Trim, Co. Meath, Ireland, 2010.

[43] D. Dannels, Generating tailored texts for museum

exhibits, in: Workshop on Language Technology forCultural Heritage Data of the Language Resources and

Evaluation Conf. Marrakech, Morocco, 2008.

[44] B. Davis, A. Iqbal, A. Funk, V. Tablan, K. Bontcheva,

H. Cunningham, S. Handschuh, Roundtrip ontology

authoring, in: 7th Int. Conf. on the Semantic Web,Karlsruhe, Germany, 2008.

[45] S. Demir, S. Carberry, K. McCoy, A discourse-aware

graph-based content-selection framework, in: 6th Int.NLG Conf. Trim, Co. Meath, Ireland, 2010.

[46] R. Denaux, V. Dimitrova, A. Cohn, C. Dolbear,

G. Hart, Rabbit to OWL: Ontology authoring with aCNL-based tool, in: N. Fuchs (ed.), Controlled Nat.

Language, vol. 5972 of Lecture Notes in Computer

Science, Springer, 2010, pp. 246–264.

[47] R. Denaux, C. Dolbear, G. Hart, V. Dimitrova,

A. Cohn, Supporting domain experts to construct

conceptual ontologies: A holistic approach, WebSemantics 9 (2) (2011) 113–127.

[48] B. Di Eugenio, D. Fossati, D. Yu, S. Haller, M. Glass,Aggregation improves learning: Experiments in natural

language generation for intelligent tutoring systems, in:

43rd Annual Meeting of ACL, Ann Arbor, MI, 2005.

[49] A. Dimitromanolaki, I. Androutsopoulos, Learning to

order facts for discourse planning in natural language

generation, in: 9th European Workshop on Nat. Lang.Generation, 10th Conf. of the European Chapter of

ACL, Budapest, Hungary, 2003.

[50] P. Duboue, K. McKeown, Empirically estimating orderconstraints for content planning in generation, in: 39th

Annual Meeting of ACL, Toulouse, France, 2001.

[51] P. Duboue, K. McKeown, Content planner constructionvia evolutionary algorithms and a corpus-based fitness

function, in: 2nd Int. Nat. Lang. Generation Conf.

Harriman, NY, 2002.

[52] P. Duboue, K. McKeown, Statistical acquisition of

content selection rules for natural language generation,in: Conf. on Empirical Methods in Nat. Language

Processing, Sapporo, Japan, 2003.

[53] M. Dzbor, E. Motta, C. Buil, J. Gomez, O. Goerlitz,H. Lewen, Developing ontologies in OWL: An

observational study, in: OWL Experiences and

Directions Workshop, Athens, GA, 2006.

[54] M. Elhadad, J. Robin, SURGE: A reusable

comprehensive syntactic realization component, in: 8th

Int. Nat. Lang. Generation Workshop, HerstmonceuxCastle, Sussex, UK, 1996.

[55] M. Elsner, J. Austerweil, E. Charniak, A unified local

and global model for discourse coherence, in: HumanLang. Technologies Conf. of the North American

Chapter of ACL, Rochester, New York, 2007.

[56] C. Fellbaum (ed.), WordNet: an electronic lexicaldatabase, MIT Press, 1998.

[57] G. Fliedl, C. Kop, J. Vohringer, From OWL classand property labels to human understandable natural

language, in: 12th Int. Conf. on Applications of Nat.Language to Information Systems, Paris, France, 2007.

[58] N. Fuchs, K. Kaljurand, T. Kuhn, Attempto Controlled

English for knowledge representation, in: C. Baroglio,

P. Bonatti, J. Maluszynski, M. Marchiori, A. Polleres,S. Schaffert (eds.), Reasoning Web, Springer-Verlag,

2008, pp. 104–124.

[59] A. Funk, V. Tablan, K. Bontcheva, H. Cunningham,B. Davis, S. Handschuh, CLOnE: Controlled language

48

for ontology editing, in: 6th Int. Semantic Web and

2nd Asian Semantic Web Conf. Busan, Korea, 2007.[60] D. Galanis, I. Androutsopoulos, Generating multi-

lingual descriptions from linguistically annotated OWLontologies: the NaturalOWL system, in: 11th European

Workshop on Nat. Lang. Generation, Schloss Dagstuhl,Germany, 2007.

[61] D. Galanis, G. Karakatsiotis, G. Lampouras,

I. Androutsopoulos, An open-source natural language

generator for OWL ontologies and its use in Protegeand Second Life, in: 12th Conf. of the European

Chapter of ACL (demos), Athens, Greece, 2009.[62] A. Gatt, A. Belz, Introducing shared tasks to NLG:

the TUNA shared task evaluation challenges, in:

E. Krahmer, M. Theune (eds.), Empirical Methods in

NLG, Springer-Verlag, 2010, pp. 264–293.[63] A. Gatt, E. Reiter, SimpleNLG: A realisation engine

for practical applications, in: 12th European Workshop

on NLG, Athens, Greece, 2009.[64] J. Gracia, E. Montiel-Ponsoda, P. Cimiano, A. Gomez-

Perez, P. Buitelaar, J. McCrae, Challenges for the

multilingual Web of Data, Web Semantics 11 (2012)63–71.

[65] B. Grau, I. Horrocks, B. Motik, B. Parsia, P. Patel-

Schneider, U. Sattler, OWL 2: The next step for OWL,Web Semantics 6 (2008) 309–322.

[66] B. Grosz, A. Joshi, S. Weinstein, Centering: a

framework for modelling the local coherence of

discourse, Comput. Linguistics 21 (2) (1995) 203–225.[67] Y. Guo, H. Wang, J. van Genabith, Dependency-based

n-gram models for general purpose sentence realisation,

Nat. Language Engineering 17 (2010) 455–483.[68] V. Haarslev, R. Moller, RACER system description, in:

1st Int. Joint Conf. on Automated Reasoning, Siena,

Italy, 2001.[69] C. Halaschek-Wiener, J. Golbeck, B. Parsia,

V. Kolovski, J. Hendler, Image browsing and natural

language paraphrases of semantic web annotations,in: 1st Workshop on Semantic Interoperability in

the European Digital Library at the 5th European

Semantic Web Conf. Tenerife, Spain, 2008.[70] C. Hallett, D. Scott, R. Power, Composing questions

through conceptual authoring, Comput. Linguistics 33

(2007) 105–133.[71] M. Halliday, Introduction to Functional Grammar, 2nd

ed., Edward Arnold, 1994.[72] M. Halliday, R. Hassan, Cohesion in English, Longman,

1976.[73] K. Harbusch, G. Kempen, Generating clausal

coordinate ellipsis multilingually: A uniform approach

based on postediting, in: 12th European Workshop onNat. Lang. Generation, Athens, Greece, 2009.

[74] G. Hart, M. Johnson, C. Dolbear, Rabbit: Developing

a control natural language for authoring ontologies, in:5th European Semantic Web Conf. Tenerife, CanaryIslands, Spain, 2008.

[75] A. Hartley, C. Paris, Multilingual document production

– from support for translating to support for authoring,Machine Translation 12 (1–2) (1997) 109–129.

[76] A. Hartley, D. Scott, J. Bateman, D. Dochev, AGILE– a system for multilingual generation of technicalinstructions, in: 8th Machine Translation Summit,

Santiago de Compostella, Spain, 2001.

[77] M. Hearst, TextTiling: Segmenting text into multi-

paragraph subtopic passages, Comput. Linguistics

23 (1) (1997) 33–64.[78] D. Hewlett, A. Kalyanpur, V. Kolovski, C. Halaschek-

Wiener, Effective NL paraphrasing of ontologies on the

Semantic Web, in: Workshop on End-User SemanticWeb Interaction, 4th Int. Semantic Web Conf. Galway,

Ireland, 2005.[79] H. Horacek, A best-first search algorithm for generating

referring expressions, in: 10th Conf. of the EuropeanChapter of ACL, Budapest, Hungary, 2003.

[80] E. Hovy, Automatic discourse generation using

discourse structure relations, Artificial Intelligence63 (1–2) (1993) 341–385.

[81] A. Isard, Choosing the best comparison under the

circumstances, in: Int. Workshop on PersonalizationEnhanced Access to Cultural Heritage, 11th Int. Conf.

on User Modeling, Corfu, Greece, 2007.[82] A. Isard, J. Oberlander, I. Androutsopoulos,

C. Matheson, Speaking the users’ languages, IEEE

Intelligent Systems 18 (1) (2003) 40–45.[83] K. Kaljurand, Attempto controlled english as a

Semantic Web language, Ph.D. thesis, Faculty ofMathematics and Computer Science, University of

Tartu, Estonia (2007).[84] K. Kaljurand, N. Fuchs, Verbalizing OWL in Attempto

Controlled English, in: 3rd Int. Workshop on OWL:

Experiences and Directions, Innsbruck, Austria, 2007.[85] G. Karakatsiotis, Automatic generation of comparisons

in a natural language generation system, MSc thesis,

Department of Informatics, Athens University of

Economics and Business, in Greek (2007).[86] G. Karakatsiotis, D. Galanis, G. Lampouras,

I. Androutsopoulos, NaturalOWL: Generating texts

from OWL ontologies in Protege and in Second Life, in:18th European Conf. on Artificial Intelligence (demos),

Patras, Greece, 2008.[87] N. Karamanis, C. Mellish, M. Poesio, J. Oberlander,

Evaluating centering for information ordering using

corpora, Comput. Linguistics 35 (1) (2009) 29–46.[88] A. Karasimos, A. Isard, Multi-lingual evaluation of

a natural language generation system, in: 4th Int.Conf. on Language Resources and Evaluation, Lisbon,

Portugal, 2004.[89] R. Kasper, R. Whitney, SPL: A sentence plan language

for text generation, Tech. rep., Information Sciences

Institute, University of Southern California (1989).[90] E. Kaufmann, A. Bernstein, Evaluating the usability

of natural language query languages and interfaces

to Semantic Web knowledge bases, Web Semantics 8

(2010) 377–393.[91] C. Kelly, A. Copestake, N. Karamanis, Investigating

content selection for language generation using machine

learning, in: 12th European Workshop on Nat. Lang.Generation, Athens, Greece, 2010.

[92] R. Kibble, R. Power, Optimizing referential coherence

in text generation, Comp. Ling. 30 (4) (2004) 401–416.[93] J. Kim, R. Mooney, Generative alignment and semantic

parsing for learning from ambiguous supervision, in:

23rd Int. Conf. on Comput. Ling., Beijing, China, 2010.[94] W. Kintsch, J. Keenan, Reading rate and retention as a

function of the number of propositions in the text base

of sentences, Cognitive Psychology 5 (1973) 257–274.

49

[95] W. Kintsch, T. van Dijk, Towards a model of text

comprehension and production, Psychological Review

85 (1978) 363–394.

[96] S. Konstantopoulos, I. Androutsopoulos, H. Baltzakis,V. Karkaletsis, C. Matheson, A. Tegos, P. Trahanias,

INDIGO: Interaction with personality and dialogueenabled robots, in: 18th European Conf. on Artificial

Intelligence, (demos), Patras, Greece, 2008.

[97] S. Konstantopoulos, A. Tegos, D. Bilidas,

I. Androutsopoulos, G. Lampouras, P. Malakasiotis,C. Matheson, O. Deroo, Adaptive natural language

interaction, in: 12th Conf. of the European Chapter of

ACL (demos), Athens, Greece, 2009.

[98] I. Konstas, M. Lapata, Concept-to-text generation via

discriminative reranking, in: 50th Annual Meeting of

the ACL, Jeju Island, Korea, 2012.

[99] I. Konstas, M. Lapata, Unsupervised concept-to-text generation with hypergraphs, in: Human Lang.

Technology Conf. of the North American Chapter ofACL, Montreal, Canada, 2012.

[100] E. Krahmer, M. Theune (eds.), Empirical Methods in

Nat. Lang. Generation, Springer, 2010.

[101] E. Krahmer, K. van Deemter, Computationalgeneration of referring expressions: A survey, Comput.

Linguistics 38 (1) (2012) 173–218.

[102] E. Krahmer, S. van Erk, A. Verleg, Graph-

based generation of referring expressions, Comput.Linguistics 29 (1) (2003) 53–72.

[103] T. Kuhn, R. Schwitter, Writing support for controlled

natural languages, in: Australasian Lang. TechnologyAssociation Workshop, Hobart, Australia, 2008.

[104] I. Langkilde, Forest based statistical sentence

generation, in: 1st Conf. of the North AmericanChapter of ACL, Seattle, WA, 2000.

[105] I. Langkilde, K. Knight, Generation that exploits

corpus-based statistical knowledge, in: 36th Annual

Meeting of ACL and the 17th Int. Conf. on Comput.Linguistics, vol. 1, Montreal, Quebec, Canada, 1998.

[106] I. Langkilde-Geary, An empirical verification of

coverage and correctness for a general-purpose sentencegenerator, in: 2nd Int. Nat. Lang. Generation

Workshop, Harriman, NY, 2002.

[107] B. Lavoie, O. Rambow, A fast and portable realizer fortext generation systems, in: 5th Conf. on Applied Nat.

Language Processing, Washington DC, 1997.

[108] P. Liang, M. Jordan, D. Klein, Learning semantic

correspondences with less supervision, in: 47th AnnualMeeting of ACL and 4th Conf. of AFNLP, Suntec,

Singapore, 2009.

[109] S. Liang, D. Scott, R. Stevens, A. Rector, Unlockingmedical ontologies for non-ontology experts, in: 10th

Workshop on Biomedical Nat. Language Processing,Portland, OR, 2011.

[110] S. Liang, R. Stevens, D. Scott, A. Rector, Automaticverbalisation of SNOMED classes using OntoVerbal,in: 13th Conf. on AI in Medicine, Bled, Slovenia, 2011.

[111] B. Lonneker-Rodman, C. Baker, The FrameNet modeland its applications, Nat. Language Engineering 15 (3)(2009) 414–453.

[112] N. Madnani, B. Dorr, Generating phrasal andsentential paraphrases: A survey of data-drivenmethods, Comput. Linguistics 36 (3) (2010) 341–387.

[113] W. Mann, S. Thompson, Rhetorical structure theory:A theory of text organization, Text 8 (3) (1998) 243–

281.[114] T. Marciniak, M. Strube, Beyond the pipeline: Discrete

optimization in NLP, in: 9th Conf. on Comput. Nat.Language Learning, Ann Arbor, MI, 2005.

[115] M. Marge, A. Isard, J. Moore, Creation of a new

domain and evaluation of comparison generation in a

natural language generation system, in: 5th Int. Nat.Lang. Generation Conf. Salt Fork, OH, 2008.

[116] K. McKeown, Text generation, Cambridge University

Press, 1985.[117] S. McRoy, S. Channarukul, S. Ali, An augmented

template-based approach to text realization, Nat.

Language Engineering 9 (4) (2003) 381–420.[118] A. Melengoglou, Multilingual aggregation in the M-

PIRO system, Master’s thesis, School of Informatics,

University of Edinburgh, UK (2002).[119] C. Mellish, Using Semantic Web technology to support

NLG – case study: OWL finds RAGS, in: 6th Int. NLGConf. Trim, Co. Meath, Ireland, 2010.

[120] C. Mellish, A. Knott, J. Oberlander, M. O’Donnell,Experiments using stochastic search for text planning,

in: Proceesings of the 9th Int. Workshop on NLG,

Niagara-on-the-Lake, Ontario, Canada, 1998.[121] C. Mellish, J. Pan, Finding subsumers

for natural language presentation, in: Int. Workshop

on Description Logics, Windermere, England, 2006.[122] C. Mellish, J. Pan, Nat. lang. directed inference from

ontologies, Artificial Intelligence 172 (2008) 1285–1315.[123] C. Mellish, D. Scott, L. Cahill, D. Paiva, R. Evans,

M. Reape, A reference architecture for nat. lang.generation systems, Nat. Language Engineering 12

(2006) 1–34.[124] C. Mellish, X. Sun, Natural language directed inference

in the presentation of ontologies, in: 10th EuropeanWorkshop on NLG, Aberdeen, UK, 2005.

[125] C. Mellish, X. Sun, The Semantic Web as a linguisticresource: opportunities for nat. lang. generation,

Knowledge Based Systems 19 (2006) 298–303.[126] M. Milosavljevic, The automatic generation of

comparison in descriptions of entities, Ph.D. thesis,Department of Computing, Macquarie University,

Australia (1999).[127] E. Montiel-Ponsoda, G. A. de Cea, A. Gomez-Perez,

W. Peters, Enriching ontologies with multilingualinformation, Nat. Lang. Eng. 17 (2010) 283–309.

[128] J. Moore, C. Paris, Planning text for advisory

dialogues: Capturing intentional and rhetorical

information, Comp. Ling. 19 (4) (1993) 651–694.[129] B. Motik, R. Shearer, I. Horrocks, Optimized reasoning

in descr. logics using hypertableaux, in: 21st Int. Conf.on Automated Deduction, Bremen, Germany, 2007.

[130] A. Nenkova, J. Chae, A. Louis, E. Pitler, Structural

features for predicting the linguistic quality of text, in:E. Krahmer, M. Theune (eds.), Empirical Methods inNat. Lang. Generation, Springer, 2010, pp. 222–241.

[131] J. Oberlander, G. Karakatsiotis,

A. Isard, I. Androutsopoulos, Building an adaptive

museum gallery in Second Life, in: Museums and theWeb, Montreal, Quebec, Canada, 2008.

[132] M. O’Donnell, C. Mellish, J. Oberlander, A. Knott,ILEX: an architecture for a dynamic hypertext

50

generation system, Nat. Language Engineering 7 (3)

(2001) 225–250.[133] I. Paraboni, K. van Deemter, J. Masthoff, Generating

referring expressions: making referents easy to identify,Comput. Linguistics 33 (2).

[134] C. Paris, N. Colineau, A. Lampert, K. V. Linden,

Discourse planning for information compositionand delivery: A reusable platform, Nat. Language

Engineering 16 (1) (2009) 61–98.[135] M. Poesio, R. Stevenson, B. Di Eugenio, Centering:

A parameter theory and its instantiations, Comput.

Linguistics 30 (3) (2004) 309–363.[136] R. Power, Towards a generation-based semantic web

authoring tool, in: 12th European Workshop on Nat.Lang. Generation, Athens, Greece, 2009.

[137] R. Power, Complexity assumptions in ontology

verbalisation, in: 48th Annual Meeting of ACL (shortpapers), Uppsala, Sweden, 2010.

[138] R. Power, Deriving rhetorical relationships from

semantic content, in: 13th European Workshop on Nat.

Lang. Generation, Nancy, France, 2011.[139] R. Power, D. Scott, Multilingual authoring using

feedback texts, in: 17th Int. Conf. on Comput.

Linguistics and the 36th Annual Meeting of ACL,Montreal, Canada, 1998.

[140] R. Power, R. Stevens, D. Scott, A. Rector, Editing

OWL through generated CNL, in: Workshop onControlled Nat. Lang., Marettimo Island, Italy, 2009.

[141] R. Power, A. Third, Expressing OWL axioms by

English sentences: Dubious in theory, feasible in

practice, in: 23rd Int. Conf. on Comput. Linguistics(posters), Beijing, China, 2010.

[142] A. Ratnaparkhi, Trainable methods for surface natural

language generation, in: 1st Conf. of the NorthAmerican Chapter of ACL, Seattle, WA, 2000.

[143] A. Rector, N. Drummond, M. Horridge, J. Rogers,

H. Knublauch, R. Stevens, H. Wang, C. Wroe,

OWL pizzas: Practical experience of teaching OWL-DL: Common errors and common patterns, in: 14th

Int. Conf. on Knowledge Engineering and KnowledgeManagement, Northamptonshire, UK, 2004.

[144] E. Reiter, NLG vs. templates, in: 5th EuropeanWorkshop on Nat. Lang. Generation, Leiden, The

Netherlands, 1995.[145] E. Reiter, R. Dale, Building Natural Language

Generation systems, Cambridge University Press, 2000.[146] E. Reiter, R. Robertson, L. Osman, Knowledge

acquisition for natural language generation, in: 1st Int.Conf. on NLG, Mitzpe Ramon, Israel, 2000.

[147] Y. Ren, K. van Deemter, J. Pan, Charting the potential

of description logic for the generation of referringexpressions, in: 6th Int. Nat. Lang. Generation Conf.

Trim, Co. Meath, Ireland, 2010.[148] C. Sauper, R. Barzilay, Automatically generating

Wikipedia articles: A structure-aware approach, in:Joint Conf. of the 47th Annual Meeting of ACL and

the 4th Int. Joint Conf. on Nat. Language Processingof the AFNLP, Suntec, Singapore, 2009.

[149] N. Schutte, Generating nat. language descriptions ofontology concepts, in: 12th European Workshop on

Nat. Lang. Generation, Athens, Greece, 2009.[150] R. Schwitter, English as a formal specification

language, in: 13th Int. Workshop on Database

and Expert Systems Applications, Aix-en-Provence,France, 2002.

[151] R. Schwitter, Controlled nat. languages for knowledge

representation, in: 23rd Int. Conf. on Comput.

Linguistics (posters), Beijing, China, 2010.[152] R. Schwitter, Creating and querying formal ontologies

via controlled nat. language, Applied Artificial

Intelligence 24 (2010) 149–174.[153] R. Schwitter, K. Kaljurand, A. Cregan, C. Dolbear,

G. Hart, A comparison of three controlled nat.languages for OWL 1.1, in: 4th OWL Experiences and

Directions Workshop, Washington DC, 2008.[154] R. Schwitter, M. Tilbrook, Controlled natural language

meets the Semantic Web, in: Australasian Language

Technology Workshop, Macquarie University, Sydney,Australia, 2004.

[155] N. Shadbolt, T. Berners-Lee, W. Hall, The Semantic

Web revisited, IEEE Intell. Systems 21 (2006) 96–101.[156] E. Sirin, B. Parsia, B. Grau, A. Kalyanpur, Y. Katz,

Pellet: A practical OWL-DL reasoner, Web Semantics5 (2) (2007) 51–53.

[157] R. Stevens, J. Malone, S. Williams, R. Power,Automating class definitions from OWL to English, in:

Bio-Ontologies: Semantic Applications in Life Sciences

SIG at the 18th Annual Int. Conf. on IntelligentSystems for Molecular Biology, Boston, MA, 2010.

[158] R. Stevens, J. Malone, S. Williams, R. Power, A. Third,

Automatic generation of textual class definitions from

OWL to English, Biomedical Semantics 2 (S 2:S5).[159] X. Sun, C. Mellish, Domain independent sentence

generation from RDF representations for the

Semantic Web, in: Combined Workshop on Language-

Enabled Educational Technology and Developmentand Evaluation of Robust Spoken Dialogue Systems,

European Conf. on AI, Riva del Garda, Italy, 2006.[160] X. Sun, C. Mellish, An experiment on free generation

from single RDF triples, in: 11th European Workshopon NLG, Schloss Dagstuhl, Germany, 2007.

[161] V. Tablan, T. Polajnar, H. Cunningham, K. Bontcheva,User-friendly ontology authoring using a controlled

language, in: 5th Int. Conf. on Language Resources and

Evaluation, Genoa, Italy, 2006.[162] M. Theune, E. Klabbers, J. De Pijper, E. Krahmer,

J. Odijk, From data to speech: a general approach, Nat.

Language Engineering 7 (1) (2001) 47–86.[163] D. Tsarkov, I. Horrocks, FaCT++ description logic

reasoner: System description, in: 3rd Int. Joint Conf.on Automated Reasoning, Seattle, WA, 2006.

[164] K. Van Deemter, Generating referring expressions:Boolean extensions of the Incremental Algorithm,Comput. Linguistics 28 (1) (2002) 37–52.

[165] K. van Deemter, Generating referring expressions that

involve gradable properties, Comp. Ling. 32 (2).[166] K. van Deemter, E. Krahmer, M. Theune, Real versus

template-based natural language generation: a falseopposition?, Comput. Linguistics 31 (1) (2005) 15–24.

[167] K. Van Deemter, R. Power, High-level authoring

of illustrated documents, Nat. Language Engineering9 (2) (2003) 101–126.

[168] S. Varges, C. Mellish, Instance-based natural languagegeneration, Nat. Lang. Eng. 16 (3) (2010) 309–346.

[169] D. Vogiatzis, D. Galanis, V. Karkaletsis,I. Androutsopoulos, C. Spyropoulos, A conversant

51

robotic guide to art collections, in: 2nd Workshop

on Language Technology for Cultural Heritage Data,

Language Resources and Evaluation Conf. 2008.[170] M. Walker, A. Joshi, E. Prince (eds.), Centering Theory

in Discourse, Oxford University Press, 1998.

[171] M. Walker, O. Rambow, M. Rogati, Spot: A trainablesentence planner, in: 2nd Annual Meeting of the North

American Chapter of ACL, Pittsburgh, PA, 2001.

[172] S. Wan, M. Dras, R. Dale, C. Paris, Spanning treeapproaches for statistical sentence generation, in:

E. Krahmer, M. Theune (eds.), Empirical Methods in

Nat. Lang. Generation, Springer, 2010, pp. 13–44.[173] M. White, CCG chart realization from disjunctive

inputs, in: 4th Int. Nat. Lang. Generation Conf.Sydney, Australia, 2006.

[174] G. Wilcock, Integrating natural language generation

with XML web technology, in: 10th Conf. of theEuropean Chapter of ACL (Conf. Companion),

Budapest, Hungary, 2003.

[175] G. Wilcock, Talking OWLs: towards an ontologyverbalizer, in: Workshop on Human Lang. Technology

for the Semantic Web, 2nd Int. Semantic Web Conf.

Sanibel Island, FL, 2003.[176] G. Wilcock, An overview of shallow XML-based natural

language generation, in: 2nd Baltic Conf. on Human

Lang. Technologies, Tallinn, Estonia, 2005.[177] S. Williams, R. Power, Grouping axioms for more

coherent ontology descriptions, in: 6th Int. Nat. Lang.Generation Conf. Trim, Co. Meath, Ireland, 2010.

[178] S. Williams, A. Third, R. Power, Levels of organization

in ontology verbalization, in: 13th European Workshopon Nat. Lang. Generation, Nancy, France, 2011.

[179] J. Yu, E. Reiter, H. J., C. Mellish, Choosing the content

of textual summaries of large time-series data sets, Nat.Language Engineering 13 (1) (2006) 25–49.

52

GeneratingNaturalLanguageDescriptionsfromOWLOntologies:A ... · 2012. 12. 24. · Tecra A8 is a...

Documents

Transcript of GeneratingNaturalLanguageDescriptionsfromOWLOntologies:A ... · 2012. 12. 24. · Tecra A8 is a...