Intelligent discovery for learning objects using semantic web technologies.
The Sharable Content Object Reference Model (SCORM) (ADL 2006) provides specifications for implementing e-learning systems and enabling learning object reusability and portability across diverse Learning Management Systems (LMS). The development and extension of SCORM metadata is based on IEEE Learning Object Metadata (LOM) (LOM 2005). The LOM in SCORM is used to provide consistent descriptions of SCORM-compliant learning objects, such as Content Aggregations, Activities, Sharable Content Objects, and Assets so that they can be identified, categorized, retrieved within and across systems in order to facilitate sharing and reuse.
The main problem with LOM is that it is an XML-based development, which emphasizes syntax and format rather than semantics and knowledge. Hence, even though LOM has the advantage of data transformations and digital libraries, it lacks the semantic metadata to provide reasoning and inference functions. These functions are necessary for the computer-interpretable descriptions, which are critical in the area of dynamic course decomposition, learning object mining, learning objects reusability and autoexec course generation (Kiu and Lee 2006; Balatsoukas, Morris et al. 2008). This is why most Web-based courses are still manually developed.
To improve the above problem, a mapping from LOM to statements in an RDF model has been defined (Nilsson, Palmer et al. 2003). Such a mapping allows LOM elements to be harvested as a resource of RDF statements. Additionally, RDF and related specifications are designed to make statements about the resource on the Web (that is, anything that has a URI), without the need to modify the resource itself. This enables document authors to annotate and encode the semantic relationships among resources on the Web. However, RDF alone does not provide common schema that helps to describe the resource classes and represent the types of relationships between resources. A specification with more facilities than those found in RDF to express semantics flexibly is needed. The Semantic Web (Shadbolt, Berners-Lee et al. 2006) can help solve these problems.
To enhance the knowledge representation of the XML-based markup language, the traditional Semantic Web approach is to upgrade the original XML-based to ontology-based markup language. The upgrade mentioned above from XML-based LOM to RDF-based LOM is an example. This approach is limited in that the original XML-based markup language has to be replaced with a new ontology-based markup language, causing the compatibility problems with existing data applications. This study proposes a novel integration approach that combines the first four layers of Semantic Web stack, namely URI layer, XML layer (LOM), ontology layer and rule layer. This integration approach is defined in a formal structure, called Multi-layered Semantic LOM Framework (MSLF), which is a specific sub-model of the Semantic Web stack for LOM applications. In MSLF, Semantic Web technologies can be integrated with LOM to enhance computational reasoning, and the original LOM can be retained to cooperate with ontologies and rules. That is, MSLF does not change the original schema of LOM. Hence, the existing LOM and SCORM metadata documents can continue to be used.
To demonstrate the feasibility of MSLF, an intelligent LOM shell for finding relevant learning objects, called LOFinder, is developed based on this framework. The core components of LOFinder include the LOM Base, Knowledge Base, Search Agent, and Inference Agent. It supports three different approaches for finding relevant learning objects of a certain course, namely LOM metadata, ontology-based reasoning and rule-based inference. Such dynamic finding is desirable for a number of reasons. Firstly, it is customized for each individual learning object, based on what metadata and knowledge the learning object has shown so far. Secondly, because the content or category of a learning object may keep changing, dynamic finding provides more up-to-date suggestions than a static design. Thirdly, as the number of learning objects may be large, adding suggestion links may become cumbersome for the course developer. Lastly, it can also be used at run-time to help in the decision of what content model component to deliver to the learner.
This study mainly aims to enhance the knowledge representation of LOM for computer-interpretable effects. It makes three main contributions. (1) This study defines a common framework MSLF for integrating Semantic Web technologies into LOM to facilitate machine understanding. (2) This study implements an intelligent LOFinder to demonstrate the feasibility of MSLF. LOFinder can be associated with various domain knowledge and metadata to offer dynamic relevant learning objects for different applications. (3) LOFinder can be easily transplanted to Learning Objects Repositories.
Semantic Web and Learning Objects
The section briefly discusses the current Semantic Web technologies and learning objects. Semantic Web Stack
This study primarily focuses on the first four layers of Semantic Web Stack, including URI, XML, Ontology, and Rules layers. The first layer (including Unicode and URI) and second layer (including XML, Namespace, and XML Schema) represent current web technology. URI allows any web based resource to be identified. Unicode provides the basic character set for web based resources. XML and XML Schema provide a surface syntax for structured documents, but impose no semantic constraints on the meaning of these documents.
The third layer is ontology vocabulary that is rapidly becoming a reality through the development of ontology markup languages such as RDF, RDF Schema, DAML+OIL, and OWL (Web Ontology Language) (Smith, Welty et al. 2004). These ontology markup languages enable the creation of arbitrary domain ontologies that support the unambiguous description of web content. OWL is essentially an XML encoding of an expressive Description Logic, builds upon RDF and includes a substantial fragment of RDF-Schema. OWL has more facilities for expressing meaning and semantics than RDF and RDFS, thus OWL goes beyond these languages in its ability to represent machine-readable content on the Web. Unfortunately, these ontology markup languages are insufficient for describing the conditions under which specific relations might hold, which requires the explicit representation of implications, as is provided by logic programs, such as rules. A broad consensus has evolved in the Semantic Web community that the vision of the Semantic Web includes, specifically, rules as well as ontologies. The forth layer of W3C's Semantic Web stack is rules to reflect this idea consensus view.
The term learning object is one of the main research topics in the e-learning community in the recent years. The Semantic Web is an extension of the current web in which information is given well defined meaning, better enabling computers and people to work in cooperation. Many studies (Hsu 2009; Hsu, Chi et al. 2009; Hsu, Tzeng et al. 2009; Lu, Horng et al. 2010) adopt Semantic Web to build intelligent applications in various domains. Learning objects can be considered as resources that are accessible over the Internet. Therefore, Semantic Web can be used to enhance the accessibility, reusability, and interoperability of learning objects. In recent years, several research studies have focused on adopting ontology to enhance the interoperability of learning objects. But, they do not address the issue of how Semantic Web technologies can provide LOM to facilitate machine understanding. LOFinder is first to address the issue. The following gives a brief overview on existing ontology approaches.
(Gradinarova, Zhelezov et al. 2006) explain how Semantic Web technologies based on ontologies can improve different aspects of the management of E-Learning resources. Indeed, ontologies are a means of specifying the concepts and their relationships in a particular domain of interest. (Mohan and Brooks 2003) analyze relations of learning objects and the Semantic Web, especially emphasizing importance of ontologies. Accordingly, they identify several kinds of ontologies related to learning objects: ontologies covering domain concepts, ontologies for e-learning, ontologies about teaching and learning strategies, and ontologies about physical structuring of learning objects. (Wang, Tsai et al. 2007) propose an adaptive personalized recommendation model to help recommend SCORM-compliant learning objects. This model adopts an ontological approach to perform semantic discovery as well as both preference-based and correlation-based approaches to rank the degree of relevance of learning objects to a learner's intension and preference. (Gasevic, Jovanovic et al. 2007) propose a framework for building learning object content using ontologies. In the previous work on using ontologies to describe learning objects, researchers employed ontologies exclusively for describing learning objects' metadata. Although such an approach is useful for searching learning objects, it does not provide to reuse components of learning objects.
Multi-layered Semantic LOM Framework
Formal definitions of a Multi-layered Semantic LOM Framework (MSLF), which include Web Resource, learning object, LOM, Ontology, and Semantic Mapping Mechanism, are developed for general LOM applications. In particular, each layered component is formally described with respect to LOM.
Definition 1. (Multi-layered Semantic LOM Framework) This multiple-layered semantic framework for LOM applications can be formally defined, and is called the Multiple-layered Semantic LOM Framework (MSLF). The framework consists of a tuple MSLF = <E, X, K, SMM, R> where
* E denotes a collection of learning objects LO in the URI layer (refer to Definition 2 for LO).
* X denotes a collection of LOM-based metadata documents in the XML layer (refer to Definition 3 for LOM-based metadata document).
* K denotes a collection of ontologies O in the ontology layer (refer to Definition 4 for O).
* SMM denotes the semantic mapping mechanism that defines how LOM can be combined with ontology-based knowledge (refer to Definition 5 for SMM).
* R denotes a collection of rules RLs in the rule layer (refer to Definition 6 for RL).
[FIGURE 1 OMITTED]
Figure 1 schematically depicts an illustrative example of program-markup language interactions in accordance with the framework, indicating how multiple-layered semantic Web technologies are adopted.
Example 1. Consider the concrete example given in Figure 1. Where E is a set of learning objects and X is a set of metadata coded with LOM. The software program ontology, K, is developed based on OWL and the logic program, RuleML (RuleML 2002), is taken for R.
Definition 2. (Learning Object) A learning object LO[member of]E is a tuple LO = <Rid, Uid, [A.sub.LO]>, where
* Rid denotes an unique learning object identifier, such as URI.
* Uid denotes an unique identifier of learning object owner.
* [A.sub.LO] denotes a list of learning object attributes.
Learning objects are Web-accessible entities, such as web pages, pictures, programs, audio, video, etc. They are distributed in the Internet and are identified by URI.
Definition 3. (LOM Document) A LOM-based metadata document of a learning object is a tuple LOMD = <LO, Ca, Re, Oth>, where
* LO denotes a learning object.
* Ca denotes a classification metadata that describes the meanings or abstract concepts of learning objects.
* Re denotes a relation metadata that describes the meanings or abstract concepts of relationship between learning objects.
* Oth denotes the other metadata in the LOM-based metadata document.
The LOM Information Model is broken up into nine categories. These categories are based on the definitions found in the LOM Information Model. The nine categories of metadata elements are: General category, Life Cycle category, Meta-metadata category, Technical category, Educational category, Rights category, Relation category, Annotation category, and Classification category. This study only focuses on Classification category and Relation category. The Classification category can be used to describe where the learning object falls within a particular classification system. The Relation category can be used to describe features that define the relationship between this learning object and other targeted learning objects. Each relationship is an outbound link that associates exactly two learning objects, one local and one remote, with an arc going from the former to the latter.
Definition 4. (Ontology) A web-based ontology O[member of]eK is a tuple O = <C,P,[alpha],[beta],[gamma],[sigma],[PI]>, where
* C denotes a set of concepts representing classes in an ontology.
* P denotes a set of relations representation properties in an ontology.
* [alpha] denotes the hierarchical relation function for classes. [alpha]: C [right arrow] C, where
* [alpha]([c.sub.1]) = [c.sub.2] means that [c.sub.1] is a subclass of [c.sub.2].
* This hierarchical relation can be used to determine if two classes have subclass/superclass relationship (Guarino and Welty 2004).
* [beta] denotes the hierarchical relation function for properties. [beta]: P [right arrow] P, where
* [beta]([p.sub.1]) = [p.sub.2] means that [p.sub.1] is a sub-property of [p.sub.2].
* [gamma] denotes the attribute relation function between classes. [gamma]: P [right arrow] C x C, where
* [gamma]([p.sub.1]) = ([c.sub.1], [c.sub.2]) means that domain of [p.sub.1] is [c.sub.1] and range of [p.sub.1] is [c.sub.2].
* [SIGMA] denotes a set of ontology axioms, expressed in an appropriate description logic.
* [PI] denotes a set of RDF-based ontology language, such as RDF schema, DAML + OIL, or OWL.
An ontology is commonly defined as an explicit, formal specification of a shared conceptualization of a domain of interest (Studer, Benjamins et al. 1998). It describes some application-relevant part of the world in a machine understandable way. The reasoning capabilities of OWL will be discussed in the next section.
Definition 5. (Semantic Mapping Mechanism) A semantic mapping mechanism is a tuple SMM = <LOMD, LLO, RLO, C, [LAMBDA], P, Y>, where
* LOMD denotes a learning object metadata document (as defined in Definition 3).
* LLO denotes a local learning object that is mainly described by the LOMD.
* RLO denotes a remote learning object that is related to LLO.
* C denotes a set of concepts representing classes in an ontology.
* [LAMBDA] denotes a classification mapping function. [LAMBDA]: LLO [right arrow] C
The classification mapping function can make a classification tag (element) to refer an ontology class and acquire an
additional semantic knowledge about the learning object.
[LAMBDA]([lo.sub.1]) = [c.sub.1] means that the classification of the learning object [lo.sub.1] is set to class [c.sub.1].
* P denotes a set of properties in an ontology class.
* Y denotes a relation mapping function. Y: LLO x RLO [right arrow] P
The relation mapping function can make a relation tag (element) to refer an ontology property and acquire an additional semantic knowledge about the relationship.
Y([lo.sub.1], [ro.sub.1] = [p.sub.1] means that starting learning object of [p.sub.1] is [lo.sub.1] and ending learning object of [p.sub.1] is [ro.sub.1].
In LOM, this study employs classification and relation metadata elements to provide extra semantic information. The classification element can indicate a character of the learning object has, while the relation element describes the meaning of the arc's ending learning object relative to its starting learning object. The content of both classification and relation elements are URI references that identify the learning object of the intended property. The format of this learning object is not standardized by LOM, and hence is open for proprietary semantic extensions. In the semantic LOM framework, each learning object can refer to an additional semantic through a classification element to set a specific ontology class. Similarly, each relationship between learning objects can refer to additional semantics through a relation element to set a specific ontology property.
Example 2. An example of instantiated LOM document is shown in Figure 1. Here LLO = cu-1, RLO = cu-4. Learning object references a specific ontology class through the classification mapping function as, [LAMBDA](cu-1) = XML. In addition, the outbound arc defines a specific ontology property through the relation mapping function as in the following: Y(cu-1,cu-4) = XMLParser.
Definition 6. (Rule) A rule RL[member of]R is a tuple RL = <C, P, H, B, Exp, RLP>, where
* H denotes the head of the rule. H [subset] C[union]P
* B denotes the body of the rule. B [subset] C[union]P
* Exp denotes the rule of the form 'if [b.sub.1] and [b.sub.2] and ... and [b.sub.n] then h', where
* h[member of]H, [b.sub.1], [b.sub.2], ... , [b.sub.n][member of]B * RLP denotes a set of rule logic programs, such as RuleML, XRML (Lee and Sohn 2003), SRML(Thorpe and Ke 2003) or SWRL (Horrocks, Patel-Schneider et al. 2003 ).
The existing proposals for building a rule layer on top of the ontology layer of the Semantic Web refer to rule formalisms originating from the field of Logic Programming. The Rule Markup Language (RuleML) provides a natural mark-up for Datalog rules, using XML tags such as <head>, <body>, <atom>, etc.
Example 3. In the example of Figure 1, the instantiated rule head and body can be depicted as h = treeMode [member of]P, [b.sub.1] = XMLParser [member of] P and b2= using [member of] P.
Reasoning Capabilities of OWL and RuleML
Before formally introducing LOFinder, the reasoning capabilities of OWL and RuleML are discussed. Both are essential components of LOFinder.
Reasoning Capabilities of OWL
The W3C OWL recommendation comprises three languages, given here in order of increasing expressive power: OWL Lite, OWL DL (Description Logic) and OWL Full. OWL Lite is a subset of OWL DL, which is in turn a subset of OWL Full, the most expressive language. OWL Full, extending RDF and RDF Schema to a full ontology language, provides the same set of constructors as OWL DL, but uses in an unconstrained manner. This study focuses on OWL DL, and adopts OWL to mean OWL DL without loss of generality. OWL is based on description logic (Baader, Calvanese et al. 2003), which is a subset of first-order logic that provides sound and decidable reasoning support. The OWL allows the terminological hierarchy to be specified by a restricted set of first-order formulae. Additionally, OWL supports the development of an ontology multiple- layered architecture (Hsu and Kao 2005) that effectively integrates domain level ontologies with top level ontologies. These ontologies are a popular research topic in various communities. They provide a shared and common understanding of a domain that can be communicated between people and across application systems (Studer, Benjamins et al. 1998).
XML-based RuleML Logic Program
This knowledge is most appropriate represented using implication. With implication, the author can specify that Y (the consequence) is satisfied whenever X1 ... Xn (the antecedents) are all true. One of the simplest approaches for representing such implication is through rules expressions, which could be Horn clause statements. Unfortunately, general Horn clause statements are not explicitly representable using the primitives in OWL. OWL can represent simple implication as described in the previous section, but it has no mechanism for defining arbitrary, multi-element antecedents. For example, OWL's description logics can not represent the following non-monotonic rule.
if XMLParser(XMLJAXP) and using(JAXP,DOM) then treeMode(XML,DOM)
Several researchers have shown how to interoperate, semantically and inferentially, between the leading semantic Web approaches using rules (for instance, RuleML logic programs) and ontologies (for instance, OWL description logics) by analyzing their expressive intersections (Grosof and Poon 2003).
System Architecture of LOFinder
LOFinder can be associated with various domain knowledge and metadata. The basic function of LOM is to provide metadata for e-learning applications. LOFinder supports three different approaches for finding dynamic correlation of learning object, namely LOM-based metadata, ontology-based reasoning and rule-based inference. The first approach, called LOM-based metadata, adopts XML-based LOM metadata to describe learning objects. This approach is used to develop existing e-learning applications, but still cannot intelligently locate relevant learning objects. The ontology-based reasoning approach provides OWL-based ontologies based on description logics to provide sound and decidable reasoning to LOM, and therefore can enhance the semantic reasoning capabilities of LOM. The rule-based inference approach can support inference capabilities that are complementary to those of an ontology-based reasoning approach. By building rules on top of ontologies, this approach can add intelligence based on logic programs.
The core components of LOM shell, LOFinder, include the LOM Base, Knowledge Base, Search Agent and Inference Agent. The flow-oriented LOFinder architecture is depicted in Figure 2.
* LOM Base: is an annotation repository composed of LOM-based metadata documents, which plays the same role as the fact base in a traditional expert system. A LOM-based metadata document is an XML document containing a set of relation metadata and classification metadata. The LOM Base is located on XML layer of the multi-layered semantic framework.
* Knowledge Base: is developed based on the Semantic Web technologies to support reasoning tasks, and plays the same role as the knowledge base in a traditional expert system. It is grouped into two categories: Ontology Base and Rule Base. The former corresponds to the ontology layer of the multi- layered semantic framework, while the latter corresponds to the rule layer. The Ontology Base comprises OWL- based ontologies for semantic reasoning. The Rule Base comprises RuleML-based rules to support a flexible and complex reasoning mechanism, which cannot easily be achieved by OWL-based ontologies.
* Search Agent: is a search engine that supports for a XPath query on an LOM- based metadata document collection within the LOM Base.
* Inference Agent: is an intelligent agent implemented based on a JESS-based rule engine (JESS 2007). It converts semantic of OWL-based ontologies and RuleML-based rules to JESS-based rules before starting an inference.
[FIGURE 2 OMITTED]
The information flow of the LOFinder occurs as follows.
1 The requester sends a learning object with URL to the search agent.
2 This step is the LOM-based metadata approach. The search agent relies on the request to query the LOM Base to finding all relevant LOM-based metadata documents of the learning object.
3 The transformation engine converts the LOM-based metadata to JESS-based fact.
4 This step is the ontology-based reasoning approach. The transformation engine conducts the following tasks to capture JESS-based rules:
4.1 It retrieves and parses the relevant OWL-based ontologies quoted by the classification and relation tags.
4.2 It converts these OWL-based ontologies to JESS-based rules.
5 This step is the rule-based inference approach. The transformation engine accomplish the following tasks to capture JESS-based rules:
5.1 It relies on the relevant ontologies, mentioned on the step 4.2, to query the rule base to retrieve relevant RuleML-based rules.
5.2 It converts these RuleML-based rules to JESS-based rules.
6 The JESS Rule Inference Engine derives new JESS-based facts from these existing JESS-based facts and JESS-based rules.
7 Finally, the inference agent passes the information of relevant learning objects, including LOM-based, ontology-based, and rule-based learning objects to the requester.
Domain Knowledge and Metadata Development
This section gives an example of a software domain to demonstrate how the multiple layers of semantic Web stack, i.e., LOM, OWL and RuleML, can be respectively mapped onto an LOM Base, Ontology Base, and Rule Base. The example in Figure 1 shows how this software domain is used in this study to provide the reasoning capabilities of LOFinder, which are further described in this section.
The core ingredients of an OWL-based ontology include a set of concepts, a set of properties, and the relationships between the elements of these two sets. The present/introduce SoPro ontology offers the software language classification in a high abstraction level and is used to describe the semantic- based relation between classes, such as markup language, program language, XML, XHTML, Java, JAXP, etc, involved in the software program domain. Figure 3 shows the semantic structure of SoPro ontology as a UML class diagram. The UML class diagram has as goal to give a graphical overview of the domain concepts and the relations among them. Every entity class and entity property in the diagram has already been described in detail.
The following four constraints present some partial code of the SoPro ontology to illustrate OWL-based description logics, including subclass, symmetric property, transitive property, and inverse property, respectively.
Constraint 1. subclass
OWL expression <owl:Class rdf:ID="XML"> <rdfs:subClassOf rdf:resource="#MarkupLanguage"/> </owl:Class> Semantic meaning The XML is a subclass of the MarkupLanguage. Rule expression if XML(x) then MarkupLanguage(x)
[FIGURE 3 OMITTED]
Constraint 2. symmetric property
OWL expression <owl:SymmetricProperty rdf:ID="overlap"> <rdfs:domain rdf:resource="#XML" /> <rdfs:range rdf:resource="#XML" /> </owl:SymmetricProperty> Semantic meaning The overlap relation is symmetric. Rule expression if overlap(x, y) then overlap(y, x)
Constraint 3. transitive property
OWL expression <owl:TransitiveProperty rdf:ID="include" /> <rdfs:domain rdf:resource="#MarkupLanguage" /> <rdfs:range rdf:resource="#MarkupLanguage" /> </owl:TransitiveProperty> Semantic meaning if x include with y, and y include with z then x include with z. Rule expression if include(x, y) and include(y, z) then include(x, z)
Constraint 4. inverse property
OWL expression <owl:ObjectProperty rdf:ID="application" > <owl:inverseOf rdf:resource="#standard" /> <rdfs:domain rdf:resource="#XML" /> <rdfs:range rdf:resource="#XTHML" /> </owl:ObjectProperty> Semantic meaning There is an inverse relation between application and standard. Rule expression if application (x, y) then standard(y, x)
XML-based RuleML Logic Program
The RuleML data model can represent Horn clause rules. An OWL class is treated as a unary predicate. An OWL property is treated as a binary predicate. Assertions about instances in a class are treated as rule atoms (e.g., facts) in which the class predicate appears. Assertions about property links between class instances are treated as rule atoms in which the property predicate appears. RuleML allows a predicate symbol to be a URI; this capability is used significantly herein, since the names of OWL classes are URIs.
Example 4 presents a RuleML rule for the non-monotonic rule that shows in the rule layer of Figure 1. This rule requires the representation of complex implications, a capability that goes beyond the simple implications available in OWL. This example indicates that RuleML not only provides a general implication in the form of Horn clauses, but also that its XML representation makes it the ideal choice for use with OWL. The SoPro ontology is defined in the previous section, and all its classes and properties are available to be used as elements in the rule. The RuleML rules file consists of only the LOFinder rulebase.
RuleML expression <imp name="parser method"> <_head><atom> <_opr><rel>treeMode</rel></_opr><var>XML </var><var>DOM</var> </atom></_head> <_body><and> <atom><_opr><rel>XMLParser</rel></_opr><var>XML</var><var>JAXP </var></atom> <atom><_opr><rel>using</rel></_opr><var>JAXP</var><var>DOM</var> </atom> <and></_body></imp>
if XMLParser(XML, JAXP) and using(JAXP, DOM) then treeMode(XML, DOM)
If an XML course adopts a JAXP parser that is developed by DOM then the XML course adopts DOM method to extract data.
The software domain in the example represents all learning objects as HTML documents. The following discussion illustrates how LOM can be used to annotate relationships of learning objects using the concrete examples in the Figure 1. In the URI layer, there are a number of learning objects, including XML Advance, XHTML Introduction, JAXP for XML, Java DOM, etc. In the XML layer, each learning object is described with a LOM-based metadata document that consists of classification metadata and relation metadata. These metadata can be summarized in Table 1 and Table 2 respectively. Each row in Table 1 denotes a classification concept in the LOM document, which is associated with a semantic clue that is the classification metadata of LOM. The value of a classification metadata can be mapped to an ontology class to inherit semantic knowledge. Each row in Table 2 denotes a relationship concept in the LOM document, which is associated with a semantic clue that is the relation metadata of LOM. The value of a relation metadata can be mapped to an ontology property to capture semantic relationships.
Two instances from the Table 1 and Table 2 are further revealed as follows. The classification metadata of "XML Advance" (i.e. cu-1) is annotated with the following metadata.
* learning object ID "cu-1" represents the "XML Advance" learning object.
* classification address the "XML Advance" is an instance of XML class. Therefore, "XML Advance" can inherit semantic knowledge from XML class.
* URL "http://sparc.nfu.edu.tw/~hsuic/el/xml.htm" provides physical location of "XML Advance".
[FIGURE 4 OMITTED]
Similarly, the relation metadata of "XML Advance" is annotated with the following metadata.
* start ID "cu-1" is the starting learning object.
* end ID "cu-4" is the ending learning object.
* relation address the relationship (i.e. from cu-1 to cu-2) is an instance of XMLParser property. Therefore, the relationship can inherit semantic knowledge from XMLParser property.
Relevant Learning Objects Discovery Using LOFinder
This section will explicitly demonstrate the applicability of LOFinder by describing how the LOFinder can be adopted to provide LOM-based, ontology-based and rule-based relevant learning objects discovery using the software domain example as described in the previous section. In order to demonstrate the feasibility of LOFinder, a prototype java-based LOFinder is implemented in the paper. The user interface of LOFinder is shown in the Figure 4. A course creator selects a learning object and then presses the "Query" button. The LOFinder will rely on the learning object to invoke search agent and inference agent to retrieve the relevant learning objects information.
According to the learning object ID (i.e. cu-1) received, the search engine finds all relevant LOMs in the annotations base. Since all LOMs are actually XML documents, this corresponds to performing an XPath query on each LOM, looking for learning object whose identifier has the same value as "cu-1". The search result is shown in Figure 5. The cu-1's LOM consists of an outbound link from cu-1 to cu-4. The LOM-based approach only depends on the cu-1's LOM that exhibits a number of metadata. First, the file element describes the URL address of cu-1. Second, the classification element is used to describe where cu-1 acquires a particular ontology class. Third, the relation element is used to describe features that define the relationship between cu-1 and other learning objects. For example, the kind element describes where the relationship acquires a particular ontology property, and the resource element describes where cu-1 links to a particular learning object.
This kind of approach is that directly extracts data from the original LOM to retrieve the relevant information of learning objects, so this study calls it LOM-based metadata approach. The inference agent extracts data from the relation metadata of cu-1 to show that there is an XMLParser relation from cu-1 to cu-4. The output result of LOMbased approach is shown in (A) of Figure 4.
Figure 5. The partial LOM code of the learning object cu-1 <?xml version="1.0" encoding="UTF-8"?> <resource identifier="cu-1"> <file href=" http://sparc.nfu.edu.tw/~hsuic/el/xml.htm"/> <metadata><lom> .................... <classification><purpose> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl#XML</value> </purpose></classification> <relation> <kind> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl#XMLParser </value> </kind> <resource><identifier> <catalog>learning object ID</catalog> <entry>cu-4</entry> </resource></identifier> </relation> .................... </lom></metadata> </resource>
The inference agent depends on semantics of SoPro ontology and cu-2's LOM to reason the following facts.
1. The cu-2 learning object is an instance of XHTML class (see row 2 of Table 1).
2. There is a standard relation from cu-2 to cu-1 (see row 1 of Table 2).
3. The application property is an inverse of standard property.
Base on the above facts, inference agent can reason that there is an application relation from cu-1 to cu-2. The inference result is converted to an LOM document, as shown in Figure 6. The output result of ontology-based reasoning is shown in (B) of Figure 4.
Figure 6. The ontology-based metadata created by inference agent <?xml version="1.0" encoding="UTF-8"?> <resource identifier="cu-1"> <file href="http://sparc.nfu.edu.tw/~hsuic/el/xml.htm"/> <metadata><lom> .................... <classification><purpose> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl#XML</value> </purpose></classification> <relation> <kind> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl# application</value> </kind> <resource><identifier> <catalog>learning object ID</catalog> <entry>cu-2</entry> </resource></identifier> </relation> .................... </lom></metadata> </resource>
This inference agent relies on the previous inference results, LOM-based metadata documents and RuleML rules to perform the following tasks.
1. It converts the relation metadata of LOMs (see Table 2) and previous inference results (see Figure 6) to JESS-based facts, as shown in Figure 7.
Figure 7. The relation metadata are converted to JESS-based facts (assert (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#standard ") (subject "cu-2") (object "cu-1"))) (assert (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#application") (subject "cu-1") (object "cu-2"))) (assert (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl# XMLParser ") (subject "cu-1") (object "cu-4"))) (assert (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#using") (subject "cu-4") (object "cu-3")))
2. It converts the RuleML rule (see Example 4) to JESS-based rule, as shown in Figure 8.
Figure 8. The RuleML rule is transformed to JESS-based rule (defrule student-advisor (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#XMLParser") (subject ?x) (object ?y)) (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#using") (subject ?y) (object ?z)) => (assert (triple (predicate "http://sparc.nfu.edu.tw/~hsuic/sw/ontology/ SoPro.owl#treeMode") (subject ?x) (object ?z))) )
3. It relies on the above JESS-based facts and rules to infer the rule-based learning objects. The inference can infer that there is a treeMode relation from cu-1 to cu-3. The inference result is converted to an LOM document, as shown in Figure 9. The output result of rule-based reasoning is shown in (C) of Figure 4.
Figure 9. The rule-based metadata created by inference agent <?xml version="1.0" encoding="UTF-8"?> <resource identifier="cu-1"> <file href=" http://sparc.nfu.edu.tw/~hsuic/el/xml.htm"/> <metadata><lom> ..................... <classification><purpose> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl#XML</value> </purpose></classification> <relation> <kind> <source>URI</source> <value>http://sparc.nfu.edu.tw/~hsuic/sw/ontology/SoPro.owl#treeMode </value> </kind> <resource><identifier> <catalog>learning object ID</catalog> <entry>cu-3</entry> </resource></identifier> </relation> ..................... </lom></metadata></resource>
After describing the framework for enhancing the reasoning capabilities of LOM through LOFinder, a preliminary experiment is performed to test the expressiveness of the MSLF and the reasoning capabilities of LOFinder.
The test dataset contained 125 learning objects distributed in different classes of the SoPro ontology. In addition to the test dataset, there were 217 relations annotated in LOM-based metadata documents among those learning objects. Altogether, nine rules were identified as necessary to infer for the relevant learning objects. The complete list of rules can be found in Table 3. The first six rules are ontology-based reasoning, and the first three rules do not directly support to produce learning objects but can be referred by other rules. The last three rules are rule-based inference.
The experience conditions are described as follows:
1. Experiments were performed on a 2.4 GHz Pentium IV PC with 1024 Mb of RAM, running Linux.
2. All learning objects will be processed in random and one by one by LOFinder.
3. After a learning object has processed by LOFinder, the new inference facts could be kept in the memory and the running times could be added up for each rule that is triggered in the inference.
Total run time was 48.6 seconds. The search agent executed only one search of the LOM Base before extracting the relevant information needed to retrieve LOM-based learning objects, which was completed in only 1.1 seconds. Additionally, the remaining run time was spent inferring to get new learning objects, including ontology-based links and rule-based links. In total, 387 ontology-based links and 38 rule-based links were generated. The summary of test results is shown in Table 4.
Figure 10 shows the execution time for each rule. The experimental results showed that the more complicated rule needs more running times. The inference time for rule 5 was increased by the addition of a transitive property. The inference agent must execute a complicated recursive function to derive the transitive result. Compared to unary predicates, the binary predicates such as rule4, rule5, rule 6, rule 7, rule 8, and rule 9, have longer inference times. The last three rules have longer inference times due to their numerous clauses and binary predicates.
[FIGURE 10 OMITTED]
Summary and Concluding Remarks
The LOM was developed based on the XML standard to facilitate the search, evaluation, sharing, and exchange of learning objects. The main weakness of LOM is its lack of semantic metadata needed for reasoning and inference functions. This study therefore developed LOFinder, an intelligent LOM shell based on Semantic Web technologies that enhance the semantics and knowledge representation of LOM. After introducing and defining the proposed multi-layered Semantic LOM Framework (MSLF) for LOM, the following discussion describes how the intelligence, modularity, and transparency of LOFinder enhance the discovery of learning objects.
Cloud computing is a newly emerging computing paradigm that facilitates the rapid building of a next-generation information systems via the Internet. One future work would be to extend LOFinder to support the intelligent e-learning applications in the cloud computing environment. Another future direction of development is upgrading LOFinder to a general framework for reusability, i.e., limiting the components of LOFinder to a LOM Base, Knowledge Base, Search Agent, and Inference Agent with no built-in domain knowledge in the Knowledge Base and with no domain metadata in the LOM Base. Furthermore, User-friendly interfaces are essential for enabling easy access to the LOM Base and Knowledge Base by domain experts.
ADL. (2006). Sharable Content Object Reference Model (SCORM) 2004 3rd Edition Documentation Suite. Retrieved, March 20, 2011, from http://www.adlnet.gov/downloads/
Baader, F., Calvanese, D., et al. (2003). The Description Logic Handbook, Cambridge University Press.
Balatsoukas, P., Morris, A., et al. (2008). Learning Objects Update: Review and Critical Approach to Content Aggregation. Educational Technology & Society 11(2), 119-130.
Gasevic, D., Jovanovic, J., et al. (2007). Ontology-based annotation of learning object content. Interactive Learning Environments 15(1), 1-26.
Gradinarova, B., Zhelezov, O., et al. (2006). An e-Learning Application Based on the Semantic Web Technology. IFIP 19th World Computer Congress, TC-3, Education, (pp. 75-82). Santiago, Chile, Springer.
Grosof, B. N. and Poon, T. C. (2003). SweetDeal: representing agent contracts with exceptions using XML rules, ontologies, and process descriptions. Proceedings of the Twelfth International World Wide Web Conference, WWW2003, (pp. 340 349).Budapest, Hungary, ACM.
Guarino, N. and Welty, C. A. (2004). An Overview of OntoClean. Handbook on Ontologies. S. S. a. R. Studer, Springer Verlag, 151-159.
Horrocks, I., Patel-Schneider, P. F., et al. (2003 ). SWRL: A Semantic Web Rule Language Combining OWL and RuleML. Retrieved March 20, 2011, from http://www.daml.org/2003/11/swrl/
Hsu, I.-C. (2009). SXRS: An XLink-based Recommender System using Semantic Web technologies. Expert Systems with Applications 36(2), 3795-3804.
Hsu, I.-C., Chi, L.-P., et al. (2009). A platform for transcoding heterogeneous markup documents using ontology-based metadata. Journal of Network and Computer Applications 32(3), 616-629.
Hsu, I.-C., Tzeng, Y. K., et al. (2009). OWL-L: An OWL-Based Language for Web Resources Links. Computer Standards & Interfaces 31(4), 846-855.
Hsu, I. C. and Kao, S. J. (2005). An OWL-based extensible transcoding system for mobile multi-devices. Journal of Information Science 31(3), 178-195.
JESS. (2007). JESS. Java Rule Engine API. Retrieved March 20, 2011, from http://herzberg.ca.sandia.gov/jess/
Kiu, C.-C. and Lee, C.-S. (2006). Ontology Mapping and Merging through OntoDNA for Learning Object Reusability. Educational Technology & Society 9 (3), 27-42.
Lee, J. K. and Sohn, M. M. (2003). The eXtensible Rule Markup Language. Communications of the ACM, 46(5), 59-64. LOM. (2005). IEEE LOM. Retrieved March 20, 2011, from http://ltsc.ieee.org/wg12/
Lu, E. J.-L., Horng, G., et al. (2010). Extended Relation Metadata for SCORM- based Learning Content Management Systems. Educational Technology & Society 13(1), 220-235.
Mohan, P. and Brooks (2003). Learning Objects on the Semantic Web. 2003 IEEE International Conference on Advanced Learning Technologies (ICALT 2003), (pp. 195-199). Athens, Greece, IEEE Computer Society.
Nilsson, M., Palmer, M., et al. (2003). The LOM RDF Binding - Principles and Implementation. Proceedings of the Third Annual ARIADNE conference.
RuleML. (2002). Rule Markup Language (RuleML). Retrieved March 20, 2011, from http://www.ruleml.org/
Shadbolt, N., Berners-Lee, T., et al. (2006). The Semantic Web Revisited. IEEE Intelligent Systems 21(3), 96-101.
Smith, M. K., Welty, C., et al. (2004). OWL Web Ontology Language Guide. Retrieved March 20, 2011, from http://www.w3.org/TR/owl-guide/.
Studer, R., Benjamins, V. R., et al. (1998). Knowledge engineering: Principles and methods. Data & Knowledge Engineering 25(1-2), 161-197
Thorpe, M. and Ke, C. (2003). Simple Rule Markup Language. Retrieved March 20, 2011, from http://xml.coverpages.org/srml.html
Wang, T. I., Tsai, K. H., et al. (2007). Personalized Learning Objects Recommendation based on the Semantic-Aware Discovery and the Learner Preference Pattern. Educational Technology & Society 10(3), 84-105.
Joo, Y. J., Lim, K. Y., & Kim, S. M. (2012). A Model for Predicting Learning Flow and Achievement in Corporate e-Learning. Educational Technology & Society, 15 (1), 313-325.
Department of Computer Science and Information Engineering, National Formosa
Table 1. The classification of learning objects learning classification: physical learning object ID ontology#class object cu-1 http://..../SoPro.owl#XML http://.../xml.htm cu-2 http://..../SoPro.owl#XHTML http://../xhtml.htm cu-3 http://..../SoPro.owl#DOM http://../jdom.htm cu-4 http://..../SoPro.owl#JAXP http://../jaxp.htm Table 2. The relation between learning objects start ID end ID relation: ontology#property cu-1 cu-4 http://..../SoPro.owl#XMLParser cu-2 cu-1 http://..../SoPro.owl#standard cu-4 cu-3 http://..../SoPro.owl#using Table 3. Rules list Rule number Type Rule expression Rule-1 ontology(subclass) if XML(x) then MarkupLanguage (x) Rule-2 ontology(subclass) if XHTML(x) then MarkupLanguage(x) Rule-3 ontology(subclass) if HTML(x) then MarkupLanguage(x) Rule-4 ontology(symmetric) if overlap(x, y) then overlap(y, x) Rule-5 ontology(transitive) if include(x, y) and include(y, z) then include(x, z) Rule-6 ontology(inverse) if standard(x, y) then application(y, x) Rule-7 rule if XMLParser(x, y) and using(y, z) then treeModee(x, z) Rule-8 rule if XMLParser(x, y) and event(y, z) then eventModee(x, z) Rule-9 rule if template(x, y) and format(x, z) then style(y, z) Table 4. Test results LOM-based ontology-based rule-based links links links Link numbers 217 387 38 Times (ms) 1102 21235 26331
|Printer friendly Cite/link Email Feedback|
|Publication:||Educational Technology & Society|
|Date:||Jan 1, 2012|
|Previous Article:||Shared mental models on the performance of e-Learning content development teams.|
|Next Article:||A model for predicting learning flow and achievement in corporate e- learning.|