Tools Frameworks for the Semantic Web

Tools & Frameworks for the Semantic Web - Fall 2005 Computer Engineering Department Sharif University of Technology

Outline p Jena n p Sesame n p A Semantic Web framework An architecture for storing and querying RDF data. Protégé n An environment for creating and editing ontologies and knowledge bases.

Jena

Introduction Jena is a Java framework for building Semantic Web applications. p Jena is open source software developed in HP Labs. p The Jena framework includes: p n A RDF API p n n n Reading and writing RDF in RDF/XML, N 3 and NTriples An OWL API In-memory and persistent storage RDQL support

Jena Versions p Two versions: n Jena 1 Expressive support for RDF p Limited reasoning facilities (RDQL) p n Jena 2 Ontology API included p Support for OWL included p

RDF Model p Resource: n p Property: n p Simple data type (String, Integer, etc). Statement: n p Trait, attribute or relation used to describe a resource. Literal: n p Anything that can be described with an RDF expression. Resource, united with the property and its associated value. An RDF Model is a set of statements.

RDF API of Jena Allows creating and manipulating RDF Models from Java applications. p Provides Java classes to represent: p n n n Models. Resources. Properties. Literals. Statements.

Example: vcards

Create an RDF Model String person. URI given. Name family. Name full. Name = = "http: //somewhere/John. Smith"; "John"; "Smith"; given. Name + " " + family. Name; // create an empty model Model model = Model. Factory. create. Default. Model(); Resource john. Smith = model. create. Resource(person. URI); john. Smith. add. Property(VCARD. FN, full. Name); john. Smith. add. Property(VCARD. N, model. create. Resource(). add. Property(VCARD. Given, given. Name). add. Property(VCARD. Family, family. Name));

Writing and Reading the Model p To serialize the model in XML: model. write(System. out); p To load a model in the memory: Model model = Model. Factory. create. Default. Model(); model. read(“file: c: /example. owl”);

Navigating the Model p Getting information via the URI of the resource: // retrieve the resource John Smith String john. Smith. URI = "http: //somewhere/John. Smith"; Resource j. Smith = model. get. Resource(john. Smith. URI); // retrieve the value of the property N Resource name = (Resource) j. Smith. get. Property(VCARD. N). get. Object(); // retrieve the value of the property FN String full. Name = (String) j. Smith. get. Property(VCARD. FN). get. Object();

Referring to a Model p Searching information in a model: // retrieve all the resources of the type vcard // (assuming that all such resources have a property FN) Res. Iterator it = model. list. Subjects. With. Property(VCARD. FN); while (it. has. Next()) { Resource r = it. next. Resource(); System. out. println(r); } p More advanced querying: n n Use of construction list. Statements(Selector s). Use of RDQL.

Operations on Models p. A model is a set of statements. p Support of the following operations: Union. n Intersection. n Difference. n // reading the RDF models model 1. read(new Input. Stream. Reader(in 1), ""); model 2. read(new Input. Stream. Reader(in 2), ""); // unifying RDF models Model model = model 1. union(model 2);

Ontology API of Jena Supports RDF Schema, DAML+OIL and OWL. p Language independent. p

Example: Camera Ontology

Creation of an Ontology Model Use of method create. Ontology. Model(). p Possible to specify: p n n Used language. Associated reasoning. String file. Name = "c: /ejemplo. owl"; String base. URI = "file: ///" + file. Name; Ont. Model model = Model. Factory. create. Ontology. Model(Profile. Registry. OWL_DL_LANG); model. read(new File. Reader(schema. File. Name), base. URI);

Classes are basic construction blocks. p Represented as Ont. Class. p n Example: Obtain subclasses of class Camera. Ont. Class camera = model. get. Ont. Class(cam. NS + "Camera"); for (Iterator i = camera. list. Sub. Classes(); i. has. Next(); ) { Ont. Class c = (Ont. Class) i. next(); System. out. println(c. get. Local. Name()); }

Properties p Represented via Ont. Property. Ont. Model m = Model. Factory. create. Ontology. Model(); Ont. Class Camera = m. create. Class(cam. NS + "Camera"); Ont. Class Body = m. create. Class(cam. NS + "Body"); Object. Property part = m. create. Object. Property(cam. NS + "part"); Object. Property body = m. create. Object. Property(cam. NS + "body"); body. add. Super. Property(part); body. add. Domain(Camera); body. add. Range(Body);

Complex Classes It is possible to define classes by means of operations for union, intersection, difference. p Example: p <owl: Class rdf: ID="SLR"> <owl: intersection. Of rdf: parse. Type="Collection"> <owl: Class rdf: about="#Camera"/> <owl: Restriction> <owl: on. Property rdf: resource="#view. Finder"/> <owl: has. Value rdf: resource="#Through. The. Lens"/> </owl: Restriction> </owl: intersection. Of> </owl: Class>

// create instance through. The. Lens Ont. Class Window = m. create. Class(cam. NS + "Window"); Individual through. The. Lens = m. create. Individual(cam. NS + "Through. The. Lens", Window); // create property viewfinder Object. Property viewfinder = m. create. Object. Property(cam. NS + "viewfinder"); // create restriction has. Value Has. Value. Restriction view. Through. Lens = m. create. Has. Value. Restriction(null, viewfinder, through. The. Lens); // create class Camera Ont. Class Camera = m. create. Class(cam. NS + "Camera"); // create intersection for defining class SLR Intersection. Class SLR = m. create. Intersection. Class(cam. NS + "SLR", m. create. List(new RDFNode[] {view. Through. Lens, Camera}));

Schema vs Instance Data p Schema n Possible to define: Classes p Properties (Data. Type. Property, Object. Property) p Restrictions p § Types of Data § Cardinality p Instance Data n Defining instances (individuals) of the Schema elements.

<owl: Class rdf: ID="Camera"> <rdfs: sub. Class. Of rdf: resource="#Item"/> </owl: Class> <owl: Datatype. Property rdf: ID="name"> <rdfs: domain rdf: resource="#Camera"/> <rdfs: range rdf: resource=“xsd: string"/> </owl: Datatype. Property> <camera: Camera rdf: ID="camera 1"> <camera: name>Kodak</camera: name> </camera: Camera>

Managing Instance Data URI = http: //test/camera/#Camera Ont. Class c = model. get. Ont. Class(URI +#Camera") Ont. Property p = model. get. Ont. Property(URI +#name") Individual ind = model. get. Individual(URI +#camera 1") if (ind. has. Property(p)) Statement st = ind. get. Property(p); Object l = (Object)st. get. Object();

Managing Instance Data p Other operations: n model. list. Individuals() p n individual. has. Property(Property p, Object o) p n Returns all instances of the model Returns True if there is an individual having property p with value o ont. Class. list. Instances(); p Returns all instances of the class

Jena Inference Support p Inference Deduce additional information n n The task of inferencing is carried out by reasoners Jena comprises a set of basic reasoners OWL Reasoner p DAML Reasoner p RDF Rule Reasoner p Generic Rule Reasoner p n p There is a way to include new reasoners For example: (? A rdfs: sub. Class. Of ? B) (? B rdfs: sub. Class. Of ? C) (? A rdfs: sub. Class. Of ? C)

Jena Inference Support p To reason, an Inference Model should be created p Example: Reasoner reasoner = Reasoner. Registry. get. OWLReasoner(); reasoner = reasoner. bind. Schema(schema); Inf. Model model. Inf = Model. Factory. create. Inf. Model(reasoner, data);

Ontology Validation in Jena Model schema = Model. Loader. load. Model("file: c: /Schema. owl"); Model data = Model. Loader. load. Model("file: c: /example. owl"); Reasoner reasoner = Reasoner. Registry. get. OWLReasoner(); reasoner = reasoner. bind. Schema(schema); Inf. Model model. Inf = Model. Factory. create. Inf. Model(reasoner, data); Validity. Report vrp 1 = model. Inf. validate(); if (vrp 1. is. Valid()){ System. out. println(“Valid OWL"); }else { System. out. println(“Not valid OWL"); for (Iterator i = vrp 1. get. Reports(); i. has. Next(); ){ System. out. println(" - " + i. next()); }

<camera: Camera rdf: ID="camera 1"> <camera: name>KODAK</camera: name> </camera: Camera> <owl: Datatype. Property rdf: ID="name"> <rdfs: domain rdf: resource="#Camera"/> <rdfs: range rdf: resource=“xsd: integer"/> </owl: Datatype. Property> Error (range check): Incorrectly typed literal due to range (prop, value) Culprit = http: //www. xfront. com/owl/ontologies/camera/#camera 1 Implicated node: http: //www. xfront. com/owl/ontologies/camera/#name Implicated node: 'KODAK‘

<owl: Class rdf: ID="Camera"> <rdfs: sub. Class. Of> <owl: Restriction> <owl: on. Property rdf: resource="#name" /> <owl: max. Cardinality rdf: datatype=“xsd: non. Negative. Integer">1</owl: max. Cardinality> </owl: Restriction> </rdfs: sub. Class. Of> </owl: Class> <camera: Camera rdf: ID="camera 1"> <camera: name>KODAK</camera: name> <camera: name>OLIMPUS</camera: name> </camera: Camera> Error (too many values): Too many values on max-N property (prop, class) Culprit = http: //www. xfront. com/owl/ontologies/camera/#camera 1 Implicated node: http: //www. xfront. com/owl/ontologies/camera/#name Implicated node: http: //www. xfront. com/owl/ontologies/camera/#Camera

RDQL p q 1 contains a query: SELECT ? x WHERE (? x <http: //www. w 3. org/2001/vcard-rdf/3. 0#FN> "John Smith") p For executing q 1 with a model m 1. rdf: java jena. rdfquery --data m 1. rdf --query q 1 p The outcome is: x =============== <http: //somewhere/John. Smith/>

Using RDQL from Java Code It is possible to run RDQL queries from the Java application. p The following classes are to be used for this: p n n n Query. Execution Query. Engine Query. Results Result. Binding

RDQL Example SELECT ? x, ? fname WHERE (? x <http: //www. w 3. org/2001/vcard-rdf/3. 0#FN> ? fname) Query query = new Query("SELECT. . . ") ; query. set. Source(model); Query. Execution qe = new Query. Engine(query) ; Query. Results results = qe. exec(); for (Iterator iter = results; iter. has. Next(); ) { Result. Binding res = (Result. Binding) iter. next(); Resource x = (Resource) res. get("x"); Literal fname = (Literal) res. get("fname"); System. out. println("x: " + x + " fname: " + fname); }

Persistent Models p Jena permits to create persistent models: n such as with relational databases. p Jena 2 supports: p My. SQL n Oracle n Postgre. SQL To create a persistent model: n n Model. Factory. create. Model. RDBMaker(conn). create. Model()

Example // Create a connection to DB DBConnection c = new DBConnection(DB_URL, DB_USER, DB_PASS, DB_TYPE); // Create a Model. Maker for persistent models Model. Maker maker = Model. Factory. create. Model. RDBMaker(c); // Create a new model Model model = maker. create. Model("modelo_1"); // Start transaction model. begin(); // Read a model from an XML archive model. read(in, null); // Commit a transaction model. commit();

Sesame When they were out of sight Ali Baba came down, and, going up to the rock, said, "Open, Sesame. “ --Tales of 1001 Nights

Querying Levels p RDF documents can be considered at three different levels of abstraction: 1. 2. 3. p At the syntactic level they are XML documents. At the structure level they consist of a set of triples. At the semantic level they constitute one or more graphs with partially predefined semantics. Querying at what level is the best?

Querying at the Syntactic Level p p p In this level we just have an XML document. So we can Query RDF using an XML query language. (e. g. XQuery) But RDF is not just an XML dialect. n XML: p p n RDF: p p p Has a tree structure data model. Only nodes are labeled. Has a graph structure data model. Both edges (properties) and nodes (subjects/objects) are labeled. Different ways of encoding the same information in XML are possible.

Querying at the Structure Level p In this level RDF document represents a set of triples: p p n p Advantage: Independent of the specific XML syntax. A successful query: n p (type, Book, Class) (sub. Class. Of, Famous. Writer, Writer) (has. Written, twain/mark, ISBN 00023423442) (type, twain/mark, Famous. Writer) SELECT ? x FROM … WHERE (type ? x Famous. Writer) An unsuccessful query: n SELECT ? x FROM … WHERE (type ? x Writer)

Querying at the Semantic Level p We need a query language that is sensitive to the RDF Schema primitives: n p e. g. Class, sub. Class. Of, Property, … RQL n n RDF Query Language The first proposal for a declarative query language for RDF and RDF Schema. Output of queries is again legal RDF schema code, which can be used as input of another query. A sample query: p SELECT Y FROM Famous. Writer {X}. has. Written {Y}

Sesame – Introduction & History p p Sesame: An Architecture for Storing and Querying RDF Data and Schema Information. The European On-To-Knowledge project kicked off in Feb. 2000: n n This project aims at developing ontology-driven knowledge management tools. In this project Sesame fulfills the role of storage and retrieval middleware for ontologies and metadata expressed in RDF and RDF Schema.

On-To-Knowledge Project p p Sesame is positioned as a central tool in this project. Onto. Extract: extracts ontological conceptual structures from natural-language documents. p p Onto. Edit: An ontology editor. RDF Ferret: A user front-end, that provides search and query. RDF Ferret Sesame Onto. Extract Onto. Edit

What is Sesame? p p Sesame is an open source Java framework for storing, querying and reasoning with RDF and RDF Schema. It can be used as: n n Standalone Server: A database for RDF and RDF Schema. Java Library: For applications that need to work with RDF internally.

SOAP HTTP Sesame’s Architecture Sesame HTTP Protocol Handler Admin Module SOAP Protocol Handler Query Module Export Module Repository Abstraction Layer (RAL) Repository

The Repository p DBMSs n Currently, Sesame is able to use p p p p Postgre. SQL My. SQL Oracle (9 i or newer) SQL Server Existing RDF stores RDF flat files RDF network services n n Using multiple sesame server to retrieve results for queries. This opens up the possibility of a highly distributed architecture for RDF(S) storing and querying.

Repository Abstraction Layer (RAL) p p RAL offers stable, high-level interface for talking to repositories. It is defined by an API that offers these functionalities: n n n p Data is returned in streams. (Scalability) n n p Add data Retrieve data Delete data Only small amount of data is kept in memory. Suitable for use in highly constrained environments such as portable devices. Caching data (Performance) n E. g. caching RDF schema data which is needed very frequently.

Stacking Abstraction Layers

Admin Module p p Allows incrementally inserting or deleting RDF data in/from repository. Retrieves its information form an RDF(S) source Parses it using an RDF parser Checks each (S, P, O) statement it gets from the parser for consistency with the information already present in the repository and infers implied information if necessary for instance: n n If P equals type, it infers that O must be a class. If P equals sub. Class. Of, it infers that S and O must be classes. If P equals sub. Property. Of, then it infers that both S and O must be properties. If P equals domain or range, then it infers that S must be a property and O must be a class.

Query Module p p p Evaluates RQL queries posed by the user It is independent of the underlying repository. So it can not use optimizations and query evaluations offered by specific DBMSs. RQL queries are translated into a set of calls to the RAL. n e. g. when a query contains a join operation over two subqueries, each of the subqueries is evaluated, and the join operation is then executed by the query engine on the results.

RDF Export Module p p This module allows for the extraction of the complete schema and/or data from a model in RDF format. It supplies the basis for using Sesame with other RDF tools.

Important Features of Sesame p p Powerful query language Portability n p p Repository independence Extensibility n p It is written completely in Java. Other functional modules can be created and be plugged in it. Flexible communication by using protocol handlers n The architecture separates the communication details from the actual functionality through the use of protocol handlers.

Se. RQL (Sesame RDF Query Language) It combined the best features of other query languages: RQL, RDQL, N-Triples, N 3 p Some of the built-in predicates: p n n n {X} serql: direct. Sub. Class. Of {Y} {X} serql: direct. Sub. Property. Of {Y} {X} serql: direct. Type {Y}

Using Postgre. SQL as Repository p p Postgre. SQL is an open-source object-relational DBMS. It supports subtable relations between its tables. Subtable relations are also transitive. These relations can be used to model the subsumption reasoning of RDF schema.

Example RDF Schema & Data Writer domain has. Written range Book sub. Class. Of Famous. Writer Schema Data type …/twain/mark type has. Written …/ISBN 00023423442

Storing Schema (in an RDBMS) Class Sub. Class. Of uri Resource Writer Famous. Writer Book Property uri has. Written Sub. Property. Of source Writer Famous. Writer Book target has. Written target Resource Writer Resource Domain source Range target Writer source has. Written target Book

Storing Data (Postgre. SQL) Resource uri Book Writer uri …/ISBN 00023423442 Famous. Writer uri has. Written source target …/twain/mark …/ISBN 00023423442 In order to decrease the database size another table, called resources, is added to database which maps resource descriptions to unique IDs.

RDF Schema Ambiguities p There are many ambiguities in RDFS: n n n p RDF Schema is self-describing: n p p RDF Schema is defined in natural language. No formal description of its semantic is given. E. g. about sub. Class. Of it only says that it is a property with class as its domain and range. The definition of its terms is itself done in RDF schema. As a result it consists some inconsistencies. Circular dependencies in terms definitions: n n Class is both a subclass of and an instance of Resource is an instance of Class.

Scalability Issues p An experiment using Sesame: n Uploading and querying a collection of nouns from Wordnet (http: //www. semanticweb. org/library) p n n n Consisting of about 400, 000 RDF statements. Using a desktop computer (Sun Ultra. SPARC 5 workstation, 256 MB RAM) Uploading the Wordnet nouns took 94 minutes. Querying was quite slow. p Because data is distributed over multiple tables, and retrieving data needs doing many joins on tables.

Protégé

Protégé - Introduction p Protégé is an extensible, platformindependent environment for creating and editing ontologies and knowledge bases. p Current version is 3. 1. 1 but the tutorial in the next slides is based on version 2. 1. 1

Tutorial Scenario Semantic Web for Tourism/Traveling p Goal: Find matching holiday destinations for a customer p I am looking for a comfortable destination with beach access Tourism Web

Tourism Semantic Web OWL Metadata (Individuals) Tourism Ontology OWL Metadata (Individuals) Destination Activity Accomodation OWL Metadata (Individuals) Web Services

OWL (in Protégé) Individuals (e. g. , “Four. Seasons”) p Properties p n n p Object. Properties (references) Datatype. Properties (simple values) Classes (e. g. , “Hotel”)

Individuals Represent objects in the domain p Specific things p Two names could represent the same “real -world” individual p Sydney Bondi. Beach Sydneys. Olympic. Beach

Object. Properties Link two individuals together p Relationships (0. . n, n. . m) p t Par has Bondi. Beach Sydney has. Ac como dation Four. Seasons

Inverse Properties Represent bidirectional relationships p Adding a value to one property also adds a value to the inverse property p t Par has Sydney rt. Of is. Pa Bondi. Beach

Transitive Properties If A is related to B and B is related to C then A is also related to C p Often used for part-of relationships p New. South. Wales has. P art Sydney has. P art has. Part (derived) Bondi. Beach

Datatype. Properties Link individuals to primitive values (integers, floats, strings, booleans etc) p Often: Annotation. Properties without formal “meaning” p Sydney has. Size = 4, 500, 000 is. Capital = true rdfs: comment = “Don’t miss the opera house”

Classes Sets of individuals with common characteristics p Individuals are instances of at least one class p Beach City Sydney Cairns Bondi. Beach Currawong. Beach

Range and Domain p Property characteristics n n Domain: “left side of relation” (Destination) Range: “right side” (Accomodation) Accomodation Destination n ccomodatio has. A Best. Western has. Accomod Four. Seasons Sydney ation

Domains p Individuals can only take values of properties that have matching domain n “Only Destinations can have Accomodations” Domain can contain multiple classes p Domain can be undefined: Property can be used everywhere p

Superclass Relationships Classes can be organized in a hierarchy p Direct instances of subclass are also (indirect) instances of superclasses p Cairns Sydney Canberra Coonabarabran

Class Relationships p Classes can overlap arbitrarily Retiree. Destination City Cairns Sydney Bondi. Beach

Class Disjointness p p All classes could potentially overlap In many cases we want to make sure they don’t share instances disjoint. With Urban. Area Sydney City Rural. Area Woomera Cape. York Destination

Creating a new OWL project

Creating simple classes

Creating class hierarchy and set disjoints

Creating Contact class with datatype properties

Editing details of datatype properties

Createing an object property has. Contact

Creating an object property with inverse

Creating the remaining classes and properties

Class Descriptions p p Classes can be described by their logical characteristics Descriptions are “anonymous classes” Things with three star accomodation San. Jose Retiree. Destination Sydney Blue. Mountains Things with sightseeing opportunities

Class Descriptions Define the “meaning” of classes p Anonymous class expressions are used p n n p “All national parks have campgrounds. ” “A backpackers destination is a destination that has budget accomodation and offers sports or adventure activities. ” Expressions mostly restrict property values (OWL Restrictions)

Class Descriptions: Why? Based on OWL’s Description Logic support p Formalize intentions and modeling decisions (comparable to test cases) p Make sure that individuals fulfill conditions p Tool-supported reasoning p

Reasoning with Classes p Tool support for three types of reasoning exists: n Consistency checking: Can a class have any instances? n Classification: Is A a subclass of B? n Instance classification: Which classes does an individual belong to? p For Protégé we recommend RACER.

Restrictions (Overview) p Define a condition for property values n n n p all. Values. From some. Values. From has. Value min. Cardinality max. Cardinality cardinality An anonymous class consisting of all individuals that fulfill the condition

Cardinality Restrictions p p p Meaning: The property must have at least/at most/exactly x values is the shortcut for and Example: A Family. Destination is a Destination that has at least one Accomodation and at least 2 Activities

all. Values. From Restrictions Meaning: All values of the property must be of a certain type p Warning: Also individuals with no values fulfill this condition (trivial satisfaction) p Example: Hiking is a Sport that is only possible in National. Parks p

some. Values. From Restrictions p p p Meaning: At least one value of the property must be of a certain type Others may exist as well Example: A National. Park is a Rural. Area that has at least one Campground and offers at least one Hiking opportunity

has. Value Restrictions p p p Meaning: At least one of the values of the property is a certain value Similar to some. Values. From but with Individuals and primitive values. Example: A Part. Of. Sydney is a Destination where one of the values of the is. Part. Of property is Sydney

Enumerated Classes p Consist of exactly the listed individuals One. Star. Rating Two. Star. Rating Budget. Accomodation Three. Star. Rating

Logical Class Definitions p Define classes out of other classes n n intersection. Of (and) n p union. Of (or) complement. Of (not) Allow arbitrary nesting of class descriptions (A and (B or C) and not D)

union. Of p p The class of individuals that belong to class A or class B (or both) Example: Adventure or Sports activities Adventure Sports

intersection. Of p p The class of individuals that belong to both class A and class B Example: A Budget. Hotel. Destination is a destination with accomodation that is a budget accomodation and a hotel Budget. Accomodation Hotel

Implicit intersection. Of p p When a class is defined by more than one class description, then it consists of the intersection of the descriptions Example: A luxury hotel is a hotel that is also an accomodation with 3 stars Hotel Luxury. Hotel Accomodation. With 3 Stars

complement. Of p p The class of all individuals that do not belong to a certain class Example: A quiet destination is a destination that is not a family destination Destination Quiet. Destination (grayed) Family. Destination

Class Conditions p Necessary Conditions: (Primitive / partial classes) “If we know that something is a X, then it must fulfill the conditions. . . ” p Necessary & Sufficient Conditions: (Defined / complete classes) “If something fulfills the conditions. . . , then it is an X. ”

Class Conditions (2) National. Park (not everything that fulfills these conditions is a National. Park) Quiet. Destination (everything that fulfills these conditions is a Quiet. Destination)

Classification National. Park p p Backpackers. Destination A Rural. Area is a Destination A Campground is Budget. Accomodation Hiking is a Sport Therefore: Every National. Park is a Backpackers-Destiantion

Classification (2) p p Input: Asserted class definitions Output: Inferred subclass relationships

Creating an enumerated class out of individuals

Creating a has. Value restriction

Creating a defined class

Classifying Campground

Adding restrictions to City and Capital

Creating defined class Backpackers. Destination

Creating defined class Family. Destination

Creating defined class Quiet. Destination

Creating defined class Retiree. Destination

Classification

Consistency Checking

Visualization with OWLViz

OWL Wizards

Ontology Import Adds all classes, properties and individuals from an external OWL ontology into your project p Allows to create individuals, subclasses, or to further restrict imported classes p Can be used to instantiate an ontology for the Semantic Web p

Tourism Semantic Web (2) OWL Metadata (Individuals) Tourism Ontology Destination Activity Accomodation Web Services

Ontology Import with Protégé p On the Metadata tab: n n Add namespace, define prefix Check “Imported” and reload your project

Individuals

Generated OWL File <? xml version="1. 0"? > <rdf: RDF xmlns="http: //protege. stanford. edu/plugins/owl-library/heli-bunjee. owl#" xmlns: rdf="http: //www. w 3. org/1999/02/22 -rdf-syntax-ns#" xmlns: rdfs="http: //www. w 3. org/2000/01/rdf-schema#" xmlns: owl="http: //www. w 3. org/2002/07/owl#" xmlns: dc="http: //purl. org/dc/elements/1. 1/" xmlns: travel="http: //protege. stanford. edu/plugins/owl-library/travel. owl#" xml: base="http: //protege. stanford. edu/plugins/owl-library/heli-bunjee. owl"> <owl: Ontology rdf: about=""> <owl: imports rdf: resource="http: //protege. stanford. edu/plugins/owl-library/travel. owl"/> </owl: Ontology> <owl: Class rdf: ID="Heli. Bunjee. Jumping"> <rdfs: sub. Class. Of rdf: resource="http: //protege. stanford. edu/plugins/owl-library/travel. owl#Bunjee. Jumping"/> </owl: Class> <Heli. Bunjee. Jumping rdf: ID="Manic. Super. Bunjee"> <travel: is. Possible. In> <rdf: Description rdf: about="http: //protege. stanford. edu/plugins/owl-library/travel. owl#Sydney"> <travel: has. Activity rdf: resource="#Manic. Super. Bunjee"/> </rdf: Description> </travel: is. Possible. In> <travel: has. Contact> <travel: Contact rdf: ID="MSBInc"> <travel: has. Email rdf: datatype="http: //www. w 3. org/2001/XMLSchema#string">msb@manicsuperbunjee. com </travel: has. Email> <travel: has. City rdf: datatype="http: //www. w 3. org/2001/XMLSchema#string">Sydney</travel: has. City> <travel: has. Street rdf: datatype="http: //www. w 3. org/2001/XMLSchema#string">Queen Victoria St</travel: has. Street> <travel: has. Zip. Code rdf: datatype="http: //www. w 3. org/2001/XMLSchema#int">1240</travel: has. Zip. Code> </travel: Contact> </travel: has. Contact> <rdfs: comment rdf: datatype="http: //www. w 3. org/2001/XMLSchema#string">Manic super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed. </rdfs: comment> </Heli. Bunjee. Jumping> </rdf: RDF>

Lots of other tools p RDFStore n p Raptor n p triple based database systems RAP n p RDF parser library Kowari, Gateway n p RDF framework for Perl RDF framework for PHP Validators n For RDF p n W 3 C RDF For OWL p p Wonder. Web Pellet

References p Sesame n n p User Guide for Sesame p http: //openrdf. org/doc/users/userguide. html Broekstra J. , Sesame: A Generic Architecture for Storing and Querying RDF and RDF Schema, ISWC’ 02 http: //sesame. aidministrator. nl http: //www. open. RDF. org Protégé n http: //protege. stanford. edu/ n http: //www. co-ode. org

References p Jena n Official site of Jena 2 p n Jena 2 Ontology API p n http: //jena. sourceforge. net/DB/ Jena 2 Inference support p p http: //jena. sourceforge. net/tutorial/RDQL/ Jena 2 Database Interface p n http: //jena. sourceforge. net/tutorial/RDF_API/ A Programmer's Introduction to RDQL p n http: //jena. sourceforge. net/ontology/ An Introduction to RDF and the Jena RDF API p n http: //jena. sourceforge. net/inference/ Other tools n http: //www. daml. org/tools/

The End

Tools Frameworks for the Semantic Web —