Onto-DIY - Semantic Scholar

Onto-DIY: A Flexible and Idea Inspiring Ontologybased Do-It-Yourself Architecture for Managing Data Semantics and Semantic Data Yan Tang, Christophe Debruyne, Johan Criel 1 Semantic Technology and Application Laboratory, 10G-731, Department of Computer Science, Faculty of Science and Bioengineering Vrije Universiteit Brussels, Pleinlaan 2, 1050 Ixelles, Brussels, Belgium {yan.tang, christophe.debruyne}@vub.ac.be 2

Alcatel-Lucent Bell Labs (Belgium) Copernicuslaan 50, B-2018 Antwerpen, Belgium {johan.criel}@alcatel-lucent.be

Abstract. The Do-It-Yourself (DIY) culture has been continuously articulated since mid-1920s. The goal of DIY has been gradually shifted from the solution of the “time-rich and money-poor” situation into the confirmation of personal creativities and the needs of outsourcing and social contact. This paper addresses the design of a DIY environment for managing data semantics from different intelligent components in the ITEA Do-It-Yourself Smart Experiences project (DIY-SE). In particular, it is a flexible and idea inspiring ontologybased DIY architecture named Onto-DIY. Including the DIY aspect, Onto-DIY also takes socio and community aspects into account. Keywords: Ontology Engineering, Do-It-Yourself, Ontology, Ambient Computing, Semantic Decision Table

1 Introduction and Motivation The culture of Do-It-Yourself (DIY) can be traced back to the 18th century, when the art handcrafts were proposed as a means of self-expression and helping people to avoid idleness. Recently, the spirit of DIY culture has been reformed with Internet technologies, especially in the IT/ICT domain. This trend initially became visible in DIY content creation and distribution (such as Youtube1 and Microsoft Photo Story), which is now also emerging in creating applications by providing non professional users accesses to online tools for (DIY) application creation (such as Yahoo! Pipes2, Zoho creator3 and Scratch4) and hardware assemblage (e.g., Arduino5). 1

http://www.youtube.com http://pipes.yahoo.com 3 http://creator.zoho.com/ 4 http://www.arduino.cc 5 http://scratch.mit.edu/ 2

2

Yan Tang, Christophe Debruyne, Johan Criel

Although these tools lower the barrier for end user creation, they still stay too difficult to use for non technical end users and do not allow them to define and use their own defined semantics. Hence, we propose a flexible and idea inspiring ontology-based architecture (called Onto-DIY), with which end users can manage data semantics for smart objects and services in a ubiquitous network. The related works are illustrated in [2, 4, 8]. Compared to their approaches, ours tackles the challenges of managing evolving semantics and helping non-technical people to DIY their own applications. The paper is organized as follows: the design of Onto-DIY will be discussed in section 2. We will pinpoint the problem space by introducing a naughty boy use case. Then, we will discuss three DIY aspects/problems in Onto-DIY and the solutions. Section 3 shows the implementation and some experiments of Onto-DIY. Section 4 covers the conclusion and our future work.

2 Onto-DIY Onto-DIY allows end users to create their own applications using their own evolving semantics. We identify its challenges as below: • Data semantics. The data used by the ambient components in a ubiquitous network, such as sensors and smart devices/services, need to be meaningful and semantically rich, which allows these components to communicate unambiguously with each other6. • Expertise level of end users. The DIY aspect is required not only by computer geeks and technicians, but also by non-technical end users. They should have the means to create ambient applications. • Inspiring end users with new DIY ideas. Our architecture needs to support the DIY activities by continuously stirring the ideas of the end users. We consider the end users as the prosumers. They produce ideas, and consume the ideas produced by other people. When people start to share their new DIY solutions, more ideas will be inspired. • Evolutionary knowledge base. The knowledge base contains two parts – an ontology base and the component information databases that are vendor specific. The ontology base needs to be increasingly enriched when new concepts are introduced by end users. When a new component, e.g., a sensor, is plugged in the network, the end users should be able to manage the new incoming sensor data and use it in their own applications. These challenges are reflected in the Onto-DIY shown in Fig. 1. It involves two types of users: the technical end users (such as ontology engineers, knowledge engineers, geeks and professional programmers) and the non-technical (‘ordinary’) end users. The non-technical users use every day, the shelf smart objects and services, such as Twitter©7, Nabaztag Bunny©8, smart cameras, smart phones and screens as 6

It is also called system interoperability. http://twitter.com/ 8 http://www.nabaztag.com 7

Onto-DIY: A Flexible and Idea Inspiring Ontology-based Do-It-Yourself Architecture for Managing Data Semantics and Semantic Data 3

shown in Fig. 1. They are used as the input and outputs of Onto-DIY and can easily be extended with new ones.

Fig. 1. Onto-DIY architecture

The descriptions of the inputs, outputs and new created domain specific ambient applications are stored in the knowledge base, which contains two parts: • An ontology base, which consists of lexon base (a lexon is a binary fact type) and commitment repository [7] describing domain ontologies that are built from the domain dictionary, taxonomy, business process models and WordNet [5]. It also contains a set of Semantic Decision Tables (SDTs, [9]), which contains user defined semantically rich decision rules. • Vendor/company specific data bases that contain the information of the hardware, software components and services. Onto-DIY provides three categories/layers9 of services that can be used to manipulate the knowledge base:

9

Since the different layers of services are often implemented on separate servers we will the words layer will both words interchangeably in what follows

4


•

Ontology layer, which provides the basic ontological services, such as querying, retrieving, modifying and reasoning from the ontology base. • Meaning evolution layer provides the services that allow ontology versioning. They provide the technical users with a flexible, semiautomatic means, and supplies the non-technical users with controlled, user friendly means. It is designed based on a community-driven methodology called Meaning Evolution Support Systems (MESS, [3]). • Data semantics layer deals with mapping and interpreting data from the heterogeneous databases. The data storage for this layer is highly flexible because it stores data from various resources, such as sensor data, TV components data or software API information data. This layer allows the heterogeneous databases to be compliant to the Semantic Web standards, such as RDF(s) without having to change all the existing ones. Next to these semantic oriented services, Onto-DIY provides the functionalities that are used during the execution of the user created ambient applications. They are, for instance, as resource (sensor, service, and device) discovery, resource connection management and event triggering mechanisms. Since this article focuses on the semantics related to DIY, we will not describe these functionalities in detail. Naughty Boy Use Case Mary is a housewife with a one-year old son called James. James has discovered Mary’s iPhone and started banging his new toy. Mary decides to install an existing application called “naughty boy protector” from the Onto-DIY app-store. When James starts banging Mary’s phone again, the (Nabaztag) bunny, standing next to his crib, starts speaking loudly with the same intonation as his mother “Do not touch the iPhone, James!” It continues until Mary comes in and lays it flat again. Initially, the technicians build a few software and hardware pieces. There are preinstalled ontologies (version 1.0, created by domain experts, knowledge engineers and ontology engineers), databases and condition/action rules (including ontological commitments, SDTs and rules stored/implemented in the smart objects). One day, James starts realizing that shaking the iPhone always triggers the bunny and an angry mother. So he decides to smash the bunny. Onto-DIY gets the messages from the bunny, such as, its ears are continuously moved with force, or its switch button is tapped very rapidly. Unfortunately, the existing ubiquitous network does not know how to react. In the next subsection, we will describe how Mary can create an application (DIY her own solution) in order to react on the new situation. After Mary will create her own application successfully, her new solution will be automatically uploaded to the community portal of Onto-DIY. New DIY ideas and concepts are shared and can now be used by other people as parts for implementing their new DIY ideas or just as an inspiration. DIY Aspects Before the DIY evolution process starts, the domain experts and knowledge engineers need to create the ontology of version 1.0 (the initial version) from existing legacy databases, structural data files, domain taxonomy and domain dictionaries. The DIY process starts with the end users’ needs of extending this initial group of hardware/software pieces, when the existing ubiquitous network does not contain the


new functions that the users want. It may be triggered by at least one of the following requirements. 1: Mary wants to use concepts in her applications that are not defined yet in the ontology server. 2: Mary wants to define rules using her new concepts. 3: The data semantics server cannot find proper maps for the data information of the objects. DIY solution to Requirement 1 – concepts are not defined We use the meaning evolution server (in Fig. 1) to assist users with a communitybased means to gradually enrich the domain ontologies. This problem can be solved by applying the methodology illustrated in [3]. DIY Solution to Requirement 2 – decision rules are not defined The semantically rich decision rules in Onto-DIY are stored as SDTs. Table 1. A semantic decision table that decides the actions from the smart screen and iPhone based on the conditions of bunny ear and baby crib Condition People move Ear Pressure on Crib Action Screen shows Message iPhone rings

1 Yes Yes

2 No Yes

3 Yes No

4 No No

Message1 RingTone1 SDT Lexons

Lexon 1 Lexon 2 Lexon 3 Lexon 4 Lexon 5 Lexon 6 Commitment 1 Commitment 2 Commitment 3 Commitment 4 People move Ear Pressure on Crib Screen shows Messages iPhone rings

,

, , ,

, ,

, , ,

,

,

, , ,

,

, , , SDT Commitments EACH Bunny has EXACT ONE name. EACH Crib has EXACT ONE name. EACH Screen shows AT LEAST ONE Message Each iPhone rings with AT LEAST ONE Ring Tone. Instantiation of Decision Items “People” is James. “Ear” is the ear from the Bunny in the living room. “Crib” is James’ crib. “Pressure on Crib – Yes” means that James is in his crib. “Screen” is the smart screen in the living room. “iPhone” is Mary’s iPhone. She has only one iPhone.

An SDT is a decision table properly annotated with domain ontologies. Table 1 shows an SDT, which contains a tabular format, SDT lexons, SDT commitments and its instantiation for our use case. The ontology server communicates with the smart screen and the iPhone in order to execute the actions “Screen shows Message” and “iPhone rings” (Table 1), which are preprogrammed in the smart screen and iPhone. The concepts “Ear”, “Crib”, “Screen” and “iPhone” are defined in the ontologies. If they are not defined, then we can take the DIY solution to Requirement 1. If the conditions “People move Ear – Yes” and “Pressure on Crib – Yes” are not preprogrammed, then Mary needs to ask for the help from the professional users from

6


a community. Someone that is familiar with programming Nabaztag API10 can provide the software module of “People move Ear – Yes”. iPhone iPhone2093113 iPhoneYan23 …

Ring Tone RingTone1 RingTone25 …

Fig. 2. From ontology (left, modeled in Object Role Modeling method [6]) to databases (right)

Message1 and RingTone1 in Table 1 are the instances that are stored in the data tables Message and Ring Tone in the database. Fig. 2 shows a data table, the schema of which is derived from the commitment “Each iPhone rings with AT LEAST ONE Ring Tone”. It is where the instances of “Ring Tone” and “iPhone” are stored. Note that every decision item in an SDT has its meaning, which is not only defined in the ontology (SDT lexons and SDT commitments in Table 1), but also in natural language (see “Instantiation of Decision Items” in Table 1). These user-friendly texts are provided to the users for helping their DIY activities. DIY solution to Requirement 3 – data semantics is not defined Every smart object/service in Onto-DIY is an instance of a type. Properly assigned instances are the premise of correctly firing a decision rule in an SDT. , , Bunny VUB-C001 VUB-C002 … , Bunny VUB-C001 VUB-C002 …

,

(data table 1) Name Confusion R Super Mario …

,

, Left Ear E-C001Left E-C002Left

(data table 2) Right Ear E-C001Right E-C002Right …

Fig. 3. From ontology (left) to databases (right) Table 2. Semantic data mapping table (Message1 and RingTone1 are already instances) SDT item People move Ear Pressure on Crib Screen shows Message Message1 RingTone1 iPhone rings

Concept in the SDT item Ear Crib Screen Message Ring Tone iPhone

Mapped instance VUB-C001Right Crib-XYZ MAR-X-C12 Message1 RingTone1 iPhone2093113

When a user introduces new concept “Ear” and assigns proper constraints (e.g., Each Bunny has and only has 2 Ears), Onto-DIY will automatically update the existing database schemas that are illustrated in Fig. 3. 10

http://doc.nabaztag.com/api/home.html


Then, the user needs to retrieve the information of the bunny ears by querying the bunny using the existing APIs (e.g. the tag of the right ear of bunny “VUB-C001” is “VUB-C001Right”). Afterwards, Onto-DIY tool set will help the user to insert new data to the new data table (see data table 2 in Fig. 3). When Mary wants to use a new SDT, he needs to specify the firing events by linking the SDT with the instances in the databases. Take Table 1 as an example, Table 2 is the possible mapping between the decision items and the instances. All the instances (that refer to the smart pieces like chips and sensors) from Table 2 are installed by sensor engineers/technicians. If Mary needs more instances, she will have to ask for the help from these professional people. 3

Implementation and Experiments

Smart objects and services are often developed autonomously and therefore have heterogeneous data representations within their own systems and applications. The Onto-DIY server needs to know the communication data formats from the smart objects/services. For instance, the data format of obtaining data by querying the position of the Nabaztag’s ears and the desired format (used by the SDT engine on the Onto-DIY server). We use Ω-RIDL [10] as the mapping language. Users design and instantiate the decision rules with an SDT editor, the construction method of which can be found in [9]. When the smart bunny listener, which resides at the communication layer, gets a message from the shelf bunny, the SDT engine will process the rules, take the appropriate actions and pass the output actions to the appropriate smart object listener (e.g., an iPhone listener in our example) at the communication layer. The tests have been executed on an Apple Mac Book with 2 GHz Intel Core 2 Duo, 2 GB 1067 MHz DDR3 memory, Mac OS X version 10.5.8. Both client and server were developed in Java JDK 5.0 and the Ω-RIDL engine was wrapped around a Web service hosted on a JBoss 5.1.0.GA application server. The average time for performing a transformation is 15 milliseconds for 5 concepts. Currently, we are working on several other evaluations. The first one is to evaluate the quality of lifted concepts in the domain ontologies. The second one refers to the usability test of Onto-DIY, which is to evaluate how easy it is to help end users to DIY his/her smart environment.

4 Conclusion and Future Work In this paper, we have discussed the Onto-DIY architecture, which helps users to DIY their own applications using the evolving semantics defined by themselves. With Onto-DIY, we can manage data semantics for smart objects and services in a ubiquitous network. Flexible means of building personal semantics are the first point that we want to make in this paper.

8


The second point is how we can involve both professional and non-professional end users in the DIY cycle. The former helps to provide technical supports. The latter generates the requirements of extending the applications of an existing system. Onto-DIY helps users to continuously inspire new DIY ideas by showing the use cases (e.g., the naughty boy use case), existing solutions (e.g., how a case can be solved) and building blocks (e.g., the conditions and actions in an SDT), which is the third point in the paper. This paper shows an initial idea of using meaning evolution support systems for Onto-DIY and a simple algorithm. In the future, we will focus on an advanced algorithm including how to derive fact types from implicit information and explicit information in the databases. We will also continue the ongoing evaluations that have been listed in the previous section. Acknowledgments. The work has been supported by the EU ITEA-2 Project 2008005 "Do-it-Yourself Smart Experiences", founded by IWT 459.

References 1.

Brewster, C. and Wilks, Y. (2004): Ontologies, taxonomies, thesauri learning from texts. In: The Keyword Project: Unlocking Content through Computational Linguistics, 5-6 February 2004, Kings College, London 2. Chen, H., Fenin, T., & Joshi, A. (2004). Semantic Web in Context Broker Architecture. Paper presented at the Second IEEE International Conference on Pervasive Computing and Communications (Percom ‘04), Washington DC 3. de Moor, A., De Leenheer, P. and Meersman, R. (2006), DOGMA-MESS: A Meaning Evolution Support System for Interorganizational Ontology Engineering, Proc. of 14th ICCS conference, Springer-Verlag, V. 4068, p.189-203, Aalborg, Denmark 4. Dey, A. K. (2000). Providing architectural support for building context aware applications. In: Doctoral dissertation, College of Computing, Georgia Institute of Technology 5. Fellbaum, C. (1998): WordNet: an electronic lexical database (Language, Speech, and Communication). ISBN-10:026206197X, ISBN-13: 978-0262061971, MIT Press, Cambridge, 1998 6. Halpin, T.A. (2001): Information Modeling and Relational Databases: From Conceptual Analysis to Logical Design, San Francisco, California, Morgan Kaufman Publishers, 7. Spyns, P., Meersman, R., and Jarrar, M. (2002): Data Modeling versus Ontology Engineering, SIGMOD Record: Special Issue on Semantic Web and Data Management, Volume 31(4), p.12-17 8. Strobbe, M., Hollez, J., De Jans, G., Van Laere, O., Nelis, J., De Turck, F., Dhoedt, B., Demeester, P., Janssens, N., & Pollet, T. (2007). Design of CASP: An open enabling platform for context aware office and city services. Paper presented at the 4th International Workshop on Managing Ubiquitous Communications and Services, Munich, Germany 9. Tang, Y. and Meersman, R. (2007): On constructing semantic decision tables, in proc. of 18th International Conference on Database and Expert Systems Applications (DEXA'2007), LNCS 4653, Springer-Verlag, Berlin Heidelberg, 3~7th September, in, R. Wagner, N. Revell, and G. Pernul (Eds.), Regensburg, Germany, p.34-44 10. Trog, D., Tang, Y. and Meersman, R. (2007): Towards Ontological Commitments with ΩRIDL Markup Language. RuleML 2007: 92-106