Answering Natural Language Queries about

Rehabilitation Robotics Ontology on the Cloud

Zeynep Dogmus, Volkan Patoglu and Esra Erdem

Faculty of Engineering and Natural Sciences, Sabancı University, Istanbul, Turkey

Keywords:

Rehabilitation Robotics, Query Answering, Natural Language, Ontologies.

Abstract:

We introduce a novel method to answer natural language queries about rehabilitation robotics, over the formal

ontology REHABROBO-ONTO. For that, 1) we design and develop a novel controlled natural language for

rehabilitation robotics, called REHABROBO-CNL; 2) we introduce translations of queries in REHABROBO-

CNL into SPARQL queries, utilizing a novel concept of query description trees and description logics concepts;

3) we use an automated reasoner to ﬁnd an answer to the SPARQL query. To facilitate the use of our method

by experts, we develop an intelligent, interactive query answering system, using Semantic Web technologies,

and make it available on the cloud via Amazon web services. This interface guides the users to express their

queries in natural language and displays the answers to queries in a readable format, possibly with links to

detailed information. Easy access to information on REHABROBO-ONTO through complex queries in natural

language may help engineers inspire new rehabilitation robot designs, while also guiding practitioners to make

more informed decisions on technology based rehabilitation.

1 INTRODUCTION

Recently, the ﬁrst formal ontology about rehabilita-

tion robotics, called REHABROBO-ONTO, has been

designed and developed in OWL (Web Ontology

Language) (Horrocks et al., 2003; Antoniou and

van Harmelen, 2004), and made available on the

cloud (Dogmus et al., 2013; Dogmus et al., 2012), to

facilitate access to various kinds of information about

the existing robots. Also this effort of having a struc-

tured representation of information about rehabilita-

tion robotics is inline with the standardization efforts

of by European Network on Robotics for Neuroreha-

bilitation,

and IEEE-RAS Ontologies for Robotics

and Automation Working Group.

Such a formal ontology allows rehabilitation

robotics researchers to learn various properties of

the existing robots and access to the related publica-

tions to further improve the state-of-the-art. Physi-

cal medicine experts also can ﬁnd information about

rehabilitation robots and related publications to bet-

ter identify the right robot for a particular therapy

or patient population. Such requested information

can be obtained from REHABROBO-ONTO by ex-

http://www.rehabilitationrobotics.eu/

http://www.ieee-ras.org/industrial/standards.html

pressing the requested information as a formal query

in a query language, such as SPARQL (PrudHom-

meaux et al., 2008), and then by computing answers

to these queries by using a state-of-the-art automated

reasoner, such as PELLET (Sirin et al., 2007). How-

ever, expressing the requested information as a for-

mal query by means of formulas is challenging for

many users, including robot designers and physical

medicine experts.

This paper is concerned about the process of query

answering over REHABROBO-ONTO, and making it

easier for the users to express their queries in a nat-

ural language and to obtain answers to their queries

automatically. By this way, the users are not required

to be familiar with the underlying formal query lan-

guage, Semantic Web technologies, or automated rea-

soners. Easy access to information on REHABROBO-

ONTO through complex queries may help engineers

inspire new rehabilitation robot designs, while also

guiding practitioners to make more informed deci-

sions on technology based rehabilitation.

Our contributions can be summarized as follows.

First, we design and develop a novel controlled

natural language for rehabilitation robotics, called

REHABROBO-CNL, to express queries. We intro-

duce a method of translating natural language queries

in REHABROBO-CNL into formal SPARQL queries.

Dogmus Z., Patoglu V. and Erdem E..

Answering Natural Language Queries about Rehabilitation Robotics Ontology on the Cloud.

DOI: 10.5220/0005081400750083

In Proceedings of the International Conference on Knowledge Engineering and Ontology Development (KEOD-2014), pages 75-83

ISBN: 978-989-758-049-9

 2014 SCITEPRESS (Science and Technology Publications, Lda.)

This translation utilizes two intermediate representa-

tions: a novel tree structure, called a Query Descrip-

tion Tree (QDT), and Description Logics (DL) con-

cepts. Once the natural language query is transformed

into a formal query, we use PELLET to ﬁnd answers

to the query. To guide the users throughout the whole

process of expressing queries in REHABROBO-CNL,

and to show the computed answers to them in an un-

derstandable way, we also design and develop an in-

teractive, intelligent user interface. The overall sys-

tem is made available on the cloud via Amazon Elas-

tic Compute Cloud (Amazon EC2)

—a web service

that provides resizable compute capacity in the cloud,

and makes web-scale computing easier for develop-

ers.

2 REHABROBO-CNL: A

CONTROLLED NATURAL

LANGUAGE FOR

REHABILITATION ROBOTICS

Reasoning over REHABROBO-ONTO is done by

means of answering questions posed by the user in

natural language. To overcome the ambiguities in the

vocabulary and grammar of natural languages, we in-

troduce a Controlled Natural Language (CNL), a sub-

set of a natural language with a restricted vocabulary

and grammar. A CNL is essentially formal language,

and thus it is not difﬁcult to convert a CNL to a logic-

based formalism. In that sense, a CNL facilitates the

use of automated reasoners to ﬁnd answers to queries

expressed in a CNL.

In order to express queries about rehabilitation

robots, we designed and developed a new CNL,

called REHABROBO-CNL. Although we designed

REHABROBO-CNL considering REHABROBO-

ONTO, it is possible to expand it to support queries

about integrated knowledge resources (e.g., patients,

diseases, genetic information). Some example

queries in REHABROBO-CNL are listed below:

• What are the robots that target some wrist move-

ments with actuation=’series elastic’?

• What are the effort metrics that are evaluated by

some robots with active degree of freedom ≥ 2?

• What are the publications with clinical study and

that reference some robots with active degree of

freedom ≥ 2?

With REHABROBO-CNL, it is possible to con-

struct queries that contain nested relative clauses,

http://aws.amazon.com/ec2/

disjunctions, conjunctions, negations, and quantiﬁca-

tions; such as some, all, any, none.

To eliminate the ambiguities in nesting of con-

junctions and disjunctions, REHABROBO-CNL pro-

vides two ways of constructing a query: A query in

REHABROBO-CNL should either be in Conjunctive

Normal Form (CNF), or in Disjunctive Normal Form

(DNF). In other words, REHABROBO-CNL supports

conjunctions of simple disjunctions, and disjunctions

of simple conjunctions. An example of a query in

CNF is as follows.

What are the robots with mechanism

type=’hybrid’ and (with motion capability

=’grounded’ or with functionality=’clinic’)

and that target some wrist movements?

The part of the grammar of REHABROBO-CNL that

describes this query is shown in Table 1. The italic

functions in the grammar are used to extract relevant

information from REHABROBO-ONTO. These ontol-

ogy functions are described in Table 2.

The information extracted with the ontology func-

tions are coupled by their relevance. For instance,

only the verb “reference” can appear after the type

Publications. By matching types with verbs, it is

possible to prevent semantically wrong queries like

“What are the publications that target some shoul-

der movements?”. Similarly, it is necessary to match

verbs with types.

In addition to types and verbs, types are matched

with the relevant nouns. For instance, control modes

are matched with robots whereas actuation is matched

with movements. Further, the values for the nouns are

extracted to allow suitable entries from the users. The

values can be considered as ranges of the nouns, that

the user can choose from.

3 TRANSLATING QUERIES

FROM REHABROBO-CNL INTO

SPARQL

To answer a query in REHABROBO-CNL using auto-

mated reasoners, we transform the query into the for-

mal query language SPARQL with the following steps.

1. We parse the query as a tree.

2. We traverse the tree and obtain a description log-

ics (DL) concept description.

3. We transform the DL concept into a SPARQL con-

cept.

4. We form a SPARQL query.

KEOD2014-InternationalConferenceonKnowledgeEngineeringandOntologyDevelopment

Table 1: The Grammar of REHABROBO-CNL.

QUERY → WHATQUERY QUESTIONMARK

WHATQUERY → What are the Type() GENERALRELATION

GENERALRELATION → SIMPLERELATION NESTEDRELATION

∗

SIMPLERELATION → (that RELATIVECLAUSE)+

SIMPLERELATION → WITHRELATION

NESTEDRELATION → (and ((LP SIMPLEDISJUNCTION RP) — SIMPLECONJUNCTION))

∗

SIMPLEDISJUNCTION → (SIMPLERELATION or)

∗

SIMPLERELATION

SIMPLECONJUNCTION → (SIMPLERELATION and)

∗

SIMPLERELATION

RELATIVECLAUSE → Verb() (some | all | the) Type()

WITHRELATION → with Noun() EQCHECK Value()+

QUESTIONMARK → ?

Table 2: The Ontology Functions.

Type() Returns the types that correspond to concept names. They are: Robots, movements, users, publica-

tions and metrics.

Verb() Returns the verbs that correspond to object properties between concepts. Returns both active and

passive forms of these verbs. Active forms of these verbs are: Target, evaluate, reference, own.

Parsing a Query. To parse a REHABROBO-CNL

query, we introduce the concept of a Query Descrip-

tion Tree (QDT). A QDT is a rooted, directed tree that

consists of ﬁve types of nodes:

• root-node: Represents the sort of the query.

• that-node: Represents a relative clause beginning

with “that”.

• with-node: Represents a relative clause beginning

with “with”.

• and-node: Represents a conjunction.

• or-node: Represents a disjunction.

Every root/that/with-node characterizes a phrase

and a type/instance. An and/or-node cannot be a leaf.

For each path from the root node to a leaf node, there

can be at most one and-node and one or-node. With-

nodes are leaves only. That-node has one child only.

Consider, for instance, the QDT in Figure 1 for

the query: “What are the robots that target some

shoulder movements with actuation=’electrical’ and

(with transmission=’cable drive’ or with transmis-

sion=’direct drive’)?” The root denotes the beginning

of the query “What are the robots...”. According to

the root, the answer to the query will contain robot

names only. Since the query is about robots, the type

contained in the root is “robot”.

The relative clause about these robots is the child

of the root. Since this relative clause starts with

“that”, it is a that-node; the type contained in this node

is “shoulder movement”.

The query continues with a conjunction of two

relative clauses. Clauses joined with a conjunction

(resp., disjunction) are characterized by an and-node

(resp., or-node) as their parent.

One of conjoined the relative clauses starts with

“with”, so it is a with-node. The other relative clause

is a simple disjunction, so it is an or-node. It disjoins

two clauses, each starting with “with”; so it has two

children that are with-nodes. The with-nodes include

values of properties instead of types.

From QDT to a DL Concept. The tree represent-

ing the query, in fact, represents a concept. While

creating a query, we deﬁne a new concept and search

for its instances. Retrieved instances that ﬁt our de-

scription are the answers to our query.

By a depth-ﬁrst traversal of a QDT, we repre-

sent the corresponding concept in Description Logics

(DL) as described in Algorithm 1. For instance, for

the QDT in Figure 1, the algorithm returns the fol-

lowing concept:

Robot u ∃targets.ShoulderMovementsu

∃actuation.{electrical}u

(∃transmission.{cabledrive}t

∃transmission.{directdrive}).

It starts from the root node. Since the associated

class of the node is “robot”, our concept descrip-

tion starts with Robot. The child of the root is

an and-node, so the algorithm calls trans f orm re-

cursively for each grandchild of the root node and

conjoins the results by u. For the that-node, the

algorithm calls trans f ormT hatNode (Algorithm 2).

The that-node has no child, it involves the quanti-

ﬁer “some” over its associated class “shoulder move-

ments”. Therefore, trans f ormThatNode returns the

AnsweringNaturalLanguageQueriesaboutRehabilitationRoboticsOntologyontheCloud

root-node

that-node

with-node

“What are the robots”

“that target some shoulder movements”

“with actuation=’electrical’ ”

and-node

or-node

with-node

“with transmission=’cable drive’ ”

with-node

“with transmission=’direct drive’ ”

Figure 1: Tree representation of the sample query.

concept ∃targets.ShoulderMovements. For the

grandchild with-node of the root, since it is about

a functional property which has a speciﬁc value,

trans f ormWithNode (Algorithm 3) returns the con-

cept ∃actuation.{electrical}. In a similar way,

the depth-ﬁrst traversal of the or-node returns the last

two lines above.

From a DL Concept to a SPARQL Concept. To ob-

tain a SPARQL concept from a DL concept, we uti-

lize some of the existing translations in related publi-

cations, such as (Orsi, 2011) and (Fernandes, 2009).

We also introduce some novel transformations. Some

transformation examples are shown in Table 3. The

transformations without a citation are the novel trans-

formations.

Consider the inverse role transformation in Ta-

ble 3. DL representation of this concept corresponds

to the ﬁrst-order formula, ∃x.targets(x, y)∧ Robot(x),

which expresses that “there exists a robot x that tar-

gets a movement y”. Our transformation to SPARQL

includes two triples, having a common variable x.

The variable x should satisfy two conditions: it must

be a robot and it must target a movement y. Accord-

ing to the semantics of AND operator (denoted with a

dot) (P

erez et al., 2006), the result contains the map-

pings of x and y to the nodes in the ontology, that

agree on the nodes that correspond to x. This corre-

sponds to the existential restriction in the ﬁrst-order

formula, that should satisfy two conditions combined

with a conjunction. Therefore, evaluations of the DL

concept and the SPARQL concept return the same re-

sult.

Consider the complement transformation in Ta-

ble 3. DL representation of this concept contains a

Algorithm 1: transform.

Input : A tree T representing the concept that

the user described

Output: A DL concept description Q that

represents the concept in T

// n.class denotes associated class of node n

// n.children denotes children of node n

Q ←

n ← ﬁrst (root) node in T ;

if n is a root-node then

Q ← Q u n.class;

foreach child node c ∈ n.children do

Q ← Q utrans f orm(c);

else if n is a that-node then

Q ← Q utrans f ormT hatNode(n);

else if n is a with-node then

Q ← Q utrans f ormWithNode(n);

else if n is an and-node OR n is an or-node then

tempQ ←

foreach child node c ∈ n.children do

if n is an and-node then

tempQ ← tempQ u trans f orm(c);

else

tempQ ← tempQ t trans f orm(c);

Q ← Q u (tempQ);

return Q

negated existential quantiﬁer. SPARQL transformation

contains a triple covered with FILTER NOT EXISTS.

The triple searches for a mapping of variable x to a

node, that is related to another node AssistOn with

an edge that characterizes has Name relation. This

KEOD2014-InternationalConferenceonKnowledgeEngineeringandOntologyDevelopment

Table 3: DL to SPARQL Transformation Examples.

Constructor DL SPARQL

Concept (Fernandes, 2009) Robot ?x rdf:type ns:RehabRobots.

Role (Orsi, 2011) targets ?x ns:targets ?y.

Complement ¬∃name.{AssistOn}

FILTER NOT EXISTS {

?x ns:has Name ’AssistOn’.

}

Inverse Role ∃targets

−

.Robot

?x ns:targets ?y.

?x rdf:type ns:RehabRobots.

Existential Restriction (Orsi, 2011) ∃targets.ShoulderMovements

?x ns:targets ?y.

?y rdf:type ns:ShoulderMovements.

hasValue Restriction (Orsi, 2011) ∃name.{AssistOn} ?x ns:has Name ’AssistOn’.

Universal Restriction ∀reference.Robot

?x rr:reference ?y.

?y rdf:type rr:RehabRobots.

FILTER NOT EXISTS {

?x rr:reference ?y2.}

?y2 rdf:type rr:RehabRobots.}

Intersection (Fernandes, 2009) Robot u ∃functionality.{clinic}

?x rdf:type ns:RehabRobots.

?x ns:has Functionality ’clinic’.

Union (Fernandes, 2009)

∃functionality.{clinic}t

∃motionCapability.{grounded}

{?x ns:has Functionality ’clinic’.}

UNION

{?x ns:has Motion Capability ’grounded’.}

corresponds to an existential restriction. However, we

do not want such mappings of x. According to the se-

mantics of NOT EXISTS in a ﬁlter expression (P

erez

et al., 2006), FILTER NOT EXISTS {C} is satisﬁed if

the mapping of C is an empty set. Therefore, there

should not be any mapping of the variables in C to

a node in the ontology. The result that is returned

from our SPARQL concept does not contain any node

that satisﬁes the condition in the triple, and that corre-

sponds to a negated existential restriction: all x must

not have name AssistOn. Therefore, evaluations of

the DL concept and the SPARQL concept return the

same result.

Finally, consider the universal restriction example

in Table 3. DL description of this concept represents

the publications that reference all robots, and for that,

it contains a universal quantiﬁer. To represent this

concept with SPARQL we need to describe such pub-

lications by making sure that there is no robot in the

ontology that is not referenced by that publication. To

describe such publications in SPARQL we use an ex-

pression constructed with two FILTER NOT EXISTS.

Since a universal restriction such as ∀xA(x) corre-

sponds to a negated existential restriction ¬∃x¬A(x),

each FILTER NOT EXISTS operator in the SPARQL

query corresponds to a negation.

By applying these transformations, the DL con-

cept that is obtained from the QDT in Figure 1

Robot u ∃targets.ShoulderMovementsu

∃actuation.{electrical}u

(∃transmission.{cabledrive}t

∃transmission.{directdrive}).

is transformed into the following SPARQL concept:

?robot1 rdf:type rr:RehabRobots.

?robot1 rr:targets ?movement1.

?movement1 rdf:type rr:ShoulderMovements.

?movement1 rr:has_Actuation ’electrical’.

{?movement1 rr:has_Transmission ’cable drive’.}

UNION

{?movement1 rr:has_Transmission ’direct drive’.}

Note that these transformations are necessitated

by some queries supported by our approach, that in-

volve negation (e.g., publications that do not refer-

ence any robots with motion capability = ‘grounded’),

passive verbs (e.g., movements that are targeted by

robots), and universal quantiﬁers (e.g., robots that tar-

get all foot movements).

Obtaining a SPARQL Query. After we transform a

DL concept into a SPARQL concept, we can construct

AnsweringNaturalLanguageQueriesaboutRehabilitationRoboticsOntologyontheCloud

Algorithm 2: transformThatNode.

Input : A that-node n

Output: A DL concept description Q that

represents the concept in n

// n.class denotes associated class of node n

// n.verb denotes associated verb of node n

// n.negative denotes the negativity of node n

// n.quanti f ier denotes the quantiﬁer of node n

// n.instance denotes the instance of node n, if

exists

// n.child denotes child of node n

// n.class.identi f ierNoun denotes the noun that

identiﬁes n.class

Q ←

childQ ←

if n.child is not empty then

childQ ← trans f orm(n.child);

else if n includes an instance then

childQ ←

∃(n.class.identi f ierNoun).{n.instance};

if n.quanti f ier = ALL then

if n.verb is passive then

Q ←

Q u ∀(n.verb)

−

.((n.class) u childQ);

else

Q ←

Q u ∀(n.verb).((n.class) u childQ);

else

// If there is no quantiﬁer or the quantiﬁer is

SOME

if n.verb is passive then

Q ←

Q u ∃(n.verb)

−

.((n.class) u childQ);

else

Q ←

Q u ∃(n.verb).((n.class) u childQ);

if n.negative = True then

Q ← ¬Q;

return Q

a SPARQL query as follows. We start with a PREFIX

part and we declare the namespace (the location of an

ontology on the Web) of REHABROBO-ONTO. Next,

we continue with a SELECT clause. The instances

of type Robot, by themselves, are not meaningful to

the users. Thus, we want to display the names of the

instances to the users. We specify it with an addi-

tional triple in the beginning of the WHERE clause,

and continue the clause with the transformed SPARQL

concept:

Algorithm 3: transformWithNode.

Input : A with-node n

Output: A DL concept description Q that

represents the concept in n

// n.noun denotes associated noun of node n

// n.values denotes the list of values of node n

// n.quanti f ier denotes the quantiﬁer of node n

// n.aggregator denotes the aggregator of node n

// n.datatype denotes datatype of the noun in

node n

Q ←

if n.noun is functional then

if n.datatype = boolean then

Q ← Q u ∃(n.noun).{

n.values

ˆˆxsd :

boolean};

else

if n.aggregator =

≥

n.aggregator =

≤

then

Q ← Q u

∃(n.noun).(n.aggregator)

n.values

;

else if n.aggregator =

then

Q ← Q u ∃(n.noun).{n.values

};

else if n.aggregator =

! =

then

foreach value v ∈ n.values do

Q ← Q u ¬∃(n.noun).{v};

else

if n.quanti f ier = NO then

Q ← Q u ¬∃(n.noun).xsd : (n.datatype);

else if n.quanti f ier = ALL then

Q ← Q u ∀(n.noun).xsd : (n.datatype);

else if n.quanti f ier = SOME then

Q ← Q u ∃(n.noun).xsd : (n.datatype);

else

if n.aggregator =

then

foreach value v ∈ n.values do

Q ← Q u ∃(n.noun).{v};

else if n.aggregator =

! =

then

foreach value v ∈ n.values do

Q ← Q u ¬∃(n.noun).{v};

return Q

PREFIX rdf: <http://.../22-rdf-syntax-ns#>

PREFIX rr: <http://.../RehabOnto.owl#>

SELECT DISTINCT ?name WHERE {

?robot1 rr:has_Name ?name.

...

}

Once we obtain a SPARQL query, we can use

the DL reasoner PELLET to ﬁnd answers to queries,

through the Jena framework.

KEOD2014-InternationalConferenceonKnowledgeEngineeringandOntologyDevelopment

Figure 2: Constructing a query with the guide of an interactive, intelligent user interface.

4 INTELLIGENT USER

INTERFACE FOR QUERY

ANSWERING

We have designed an interactive, intelligent user-

interface to guide users to express their natural lan-

guage queries about rehabilitation robots, and to

present the answers to their queries with links to de-

tailed information.

The main user interface for querying includes a

drop-down list, showing the possible ways to begin a

query. Then, according to the user’s choices, it pro-

vides different types of features. It provides auto-

completion to help users enter values for nouns that

correspond to data properties of type string. If the

user should choose a concept among a hierarchy, then

it displays an accordion view and enables the user to

click on the option s/he wants. In addition, it allows

multiple selection of values for relational properties.

For functional properties, user is able to select mul-

tiple items for inequality. User can choose a number

of options among “less than or equal”, “more than or

equal”, “equal” and “not equal” while entering values

for a data property of type integer or ﬂoat. Figure 2

illustrates some parts of constructing the query “What

are the robots that target some wrist movements with

actuation=’series elastic’?” with this interface.

How the results of a query is displayed to user de-

pends on the query. For instance, if the query is about

robots, then the user sees the names of the retrieved

robots. If the query is about movements or metrics,

then the user sees the concept names instead of the in-

stance URIs which would make no sense to the user.

Note that, since the transformation of a query is

designed to construct the query over REHABROBO-

ONTO, the SPARQL query resulting from the transfor-

mation process that is displayed to the user is always

valid in the context of REHABROBO-ONTO. Also the

transformation of a query in REHABROBO-CNL to

SPARQL is deterministic, and does not involve any

ambiguities. Hence, the accuracy of the constructed

SPARQL query is always 100%.

Also note that the transformation of a query in

REHABROBO-CNL into a SPARQL query is asymp-

totically linear in time, in the size of the query:

parsing a REHABROBO-CNL query into a QDT is

done in linear time thanks to the intelligent-user in-

terface; transformation of a QDT into a DL concept

requires traversing the QDT once and thus done in

linear time; transformation of a DL concept into a

SPARQL query requires going over the DL concept

once and thus done in linear time. Indeed, the trans-

formation is quite efﬁcient in terms of computation

time: it is observed that the transformation a query

in REHABROBO-CNL into a SPARQL query usually

takes less than a few seconds of CPU time.

5 RELATED WORK

Development of natural language interfaces that pro-

vide query answering over ontologies has been sub-

ject of research for many years (Bernstein and Kauf-

AnsweringNaturalLanguageQueriesaboutRehabilitationRoboticsOntologyontheCloud

mann, 2006; Kaufmann et al., 2006; Lei et al., 2006;

Lopez et al., 2007; Kaufmann et al., 2007; Wang

et al., 2007; Frank et al., 2007; Battista et al., 2007;

Zhou et al., 2007; Cimiano et al., 2008; Tablan et al.,

2008). These studies propose various approaches over

common challenges, such as processing of the natural

language input (balancing ambiguity and expressive-

ness) and support for broad or narrow domains (porta-

bility).

There are some ontology systems, like

QACID (Ferr

andez et al., 2009), PowerAqua (Lopez

et al., 2012), FREyA (Damljanovic et al., 2012),

with natural language interfaces. QACID is designed

for a movie ontology, whereas FREyA and Pow-

erAqua have been used with different ontologies.

These systems take simple natural language queries,

translate a query into a SPARQL query (e.g., using

available parsers to obtain query triple forms), and

use a query engine to ﬁnd an answer over speciﬁed

ontologies. However, these systems are restricted

to simple forms of queries (e.g., that do not involve

negation, disjunction or relative clauses). Our query

language and query answering methods allow more

complex forms of queries. For instance, the sort of

a query like “What are the robots that target some

shoulder movements with actuation=’electrical’ and

(with transmission=’cable drive’ or with transmis-

sion=’direct drive’)?” (presented in Figure 1) is not

supported by these systems, due to nested relative

clauses. A query like “What are the publications with

clinical study and that do not reference any robots

with active degree of freedom ≤ 1?” is not supported

by these systems due to negation.

To eliminate the ambiguity of natural language

queries and to allow a larger variety of queries (Erdem

et al., 2011; Valencia-Garc

ıa et al., 2011) consider

controlled natural languages (CNLs). For instance,

(Erdem et al., 2011) develops a CNL for a speciﬁc

domain, biomedical informatics, whereas (Valencia-

Garc

ıa et al., 2011) develops a CNL for SPARQL

queries over ontologies. Our work is similar to these

related work since we also consider queries in a CNL,

but we target a different domain and more general

forms of queries (e.g., that involve negations, quan-

tiﬁers, or nested clauses). Also our method, in partic-

ular, the transformations of natural language queries

into formal queries, is different due to the underly-

ing formalisms. For instance, (Erdem et al., 2011)

transforms a CNL query into answer set program-

ming (Brewka et al., 2011) by means of a tree struc-

ture, whereas (Valencia-Garc

ıa et al., 2011) trans-

forms a CNL query into SPARQL utilizing a query on-

tology that essentially represents the grammar of the

CNL.

6 DISCUSSION AND

CONCLUSION

We have introduced a novel method to answer nat-

ural language queries about rehabilitation robotics,

over the ﬁrst formal rehabilitation robotics ontology

REHABROBO-ONTO. We have developed an intelli-

gent, interactive query answering system, using Se-

mantic Web technologies, and deployed it on the

cloud via Amazon web services.

Guiding the users

to express their complex queries in a natural language

and displaying the answers to queries in a readable

format, this user interface may help engineers inspire

new rehabilitation robot designs and practitioners to

make more informed decisions on technology based

rehabilitation.

In our approach, queries are speciﬁed in a con-

trolled natural language, called REHABROBO-CNL,

whose vocabulary and grammar are designed and de-

veloped speciﬁcally for REHABROBO-ONTO. This

limits the expressiveness of questions to some ex-

tent. On the other hand, it also has a strong advan-

tage not only by addressing the ambiguity and habit-

ability problems of natural languages, but also by al-

lowing more general forms of complex queries (some

of which cannot be handled by the ontology systems

with a full natural language interface).

Our approach transforms a CNL query into a

SPARQL query, by means of a DL concept rather than

directly. This provides us a ﬂexibility of being able

to utilize DL reasoners for query answering. It also

provides us a logical formalism to study the formal

properties of the speciﬁcation language and reasoning

methods in the future.

Our ongoing work involves evaluation of this sys-

tem by both rehabilitation engineers and physical

medicine experts. Our future work includes extension

of REHABROBO-CNL to enable complex queries

over other related ontologies, such as anatomy and

disease ontologies. It also includes investigation of

methods to partially answer queries, which do not

have any answer with respect to the underlying on-

tology.

ACKNOWLEDGEMENTS

Thanks to anonymous reviewers for useful com-

ments and suggestions. This work has been par-

tially supported by Sabanci University IRP Grant and

TUBITAK Grant 111M186.

http://ec2-54-228-52-230.eu-west-1.compute.

amazonaws.com/rehabrobo/

KEOD2014-InternationalConferenceonKnowledgeEngineeringandOntologyDevelopment

REFERENCES

Antoniou, G. and van Harmelen, F. (2004). Web ontology

language: Owl. In Handbook on Ontologies, pages

67–92.

Battista, A. D. L., Villanueva-Rosales, N., Palenychka, M.,

and Dumontier, M. (2007). SMART: A web-based,

ontology-driven, semantic web query answering ap-

plication. In Semantic Web Challenge, volume 295.

Bernstein, A. and Kaufmann, E. (2006). GINO - a guided

input natural language ontology editor. In Proc. of

ISWC, pages 144–157.

Brewka, G., Eiter, T., and Truszczynski, M. (2011). An-

swer set programming at a glance. Commun. ACM,

54(12):92–103.

Cimiano, P., Haase, P., Heizmann, J., Mantel, M., and

Studer, R. (2008). Towards portable natural lan-

guage interfaces to knowledge bases - the case of the

ORAKEL system. Data Knowl. Eng., 65(2):325–354.

Damljanovic, D., Agatonovic, M., and Cunningham, H.

(2012). FREyA: an interactive way of querying linked

data using natural language. In Proceedings of the 8th

international conference on The Semantic Web, Proc.

of ESWC, pages 125–138.

Dogmus, Z., Gezici, G., Patoglu, V., and Erdem, E. (2012).

Developing and maintaining an ontology for rehabili-

tation robotics. In Proc. of KEOD, pages 389–395.

Dogmus, Z., Papantoniou, A., Kilinc, M., Yildirim, S. A.,

Erdem, E., and Patoglu, V. (2013). Rehabilitation

robotics ontology on the cloud. In Proc. of ICORR.

Erdem, E., Erdem, Y., Erdogan, H., and Oztok, U. (2011).

Finding answers and generating explanations for com-

plex biomedical queries. In Proc. of AAAI.

Fernandes, D. Y. S. (2009). Using Semantics to Enhance

Query Reformulation in Dynamic Distributed Envi-

ronments. PhD thesis, Federal University of Pernam-

buco.

Ferr

andez, O., Izquierdo, R., Ferr

andez, S., and Vicedo,

J. L. (2009). Addressing ontology-based question an-

swering with collections of user queries. Information

Processing and Management, 45(2):175 – 188.

Frank, A., Krieger, H.-U., Xu, F., Uszkoreit, H., Crysmann,

B., Jrg, B., and Schfer, U. (2007). Question answer-

ing from structured knowledge sources. Journal of

Applied Logic, 5(1):20 – 48.

Horrocks, I., Patel-Schneider, P. F., and van Harmelen, F.

(2003). From shiq and rdf to owl: the making of a

web ontology language. J. Web Sem., 1(1):7–26.

Kaufmann, E., Bernstein, A., and Fischer, L. (2007). NLP-

Reduce: A naive but domain-independent natural lan-

guage interface for querying ontologies. In Proc. of

ESWC.

Kaufmann, E., Bernstein, A., and Zumstein, R. (2006).

Querix: A natural language interface to query ontolo-

gies based on clariﬁcation dialogs. In Proc. of ISWC,

pages 980–981.

Lei, Y., Uren, V., and Motta, E. (2006). SemSearch: A

search engine for the semantic web. In Proc. of EKAW,

pages 238–245.

Lopez, V., Fern

andez, M., Motta, E., and Stieler, N. (2012).

PowerAqua: Supporting users in querying and explor-

ing the semantic web. Semantic Web, 3(3):249–265.

Lopez, V., Uren, V., Motta, E., and Pasin, M. (2007). Aqua-

Log: An ontology-driven question answering system

for organizational semantic intranets. Web Semantics:

Science, Services and Agents on the World Wide Web,

5(2):72–105.

Orsi, G. (2011). Context Based Querying of Dynamic and

Heterogeneous Information Sources. PhD thesis, Po-

litecnico di Milano.

erez, J., Arenas, M., and Gutierrez, C. (2006). Semantics

and complexity of sparql. In The Semantic Web-ISWC

2006, pages 30–43. Springer.

PrudHommeaux, E., Seaborne, A., et al. (2008). Sparql

query language for rdf. W3C recommendation, 15.

Sirin, E., Parsia, B., Grau, B. C., Kalyanpur, A., and Katz,

Y. (2007). Pellet: A practical owl-dl reasoner. Web

Semantics: Science, Services and Agents on the World

Wide Web, 5(2):51 – 53.

Tablan, V., Damljanovic, D., and Bontcheva, K. (2008). A

natural language query interface to structured infor-

mation. In Proc. of ESWC, pages 361–375.

Valencia-Garc

ıa, R., Garc

ıa-S

anchez, F., Castellanos-

Nieves, D., and Fern

andez-Breis, J. (2011). OWL-

Path: An OWL ontology-guided query editor. Sys-

tems, Man and Cybernetics, Part A: Systems and Hu-

mans, IEEE Transactions on, 41(1):121–136.

Wang, C., Xiong, M., Zhou, Q., and Yu, Y. (2007). PANTO:

A portable natural language interface to ontologies. In

Proc. of ESWC, pages 473–487.

Zhou, Q., Wang, C., Xiong, M., Wang, H., and Yu, Y.

(2007). SPARK: adapting keyword query to seman-

tic search. In Proc. of ISWC/ASWC, pages 694–707.

AnsweringNaturalLanguageQueriesaboutRehabilitationRoboticsOntologyontheCloud