The Community for Technology Leaders

Relevance Ranking Metrics for Learning Objects

Xavier Ochoa
Erik Duval, IEEE Computer Society

Pages: pp. 34-48

Abstract—The main objective of this paper is to improve the current status of learning object search. First, the current situation is analyzed and a theoretical solution, based on relevance ranking, is proposed. To implement this solution, this paper develops the concept of relevance in the context of learning object search. Based on this concept, it proposes a set of metrics to estimate the topical, personal, and situational relevance dimensions. These metrics are calculated mainly from usage and contextual information and do not require any explicit information from users. An exploratory evaluation of the metrics shows that even the simplest ones provide statistically significant improvement in the ranking order over the most common algorithmic relevance metric. Moreover, combining the metrics through learning algorithms sorts the result list 50 percent better than the baseline ranking.

Index Terms—Learning objects, relevance ranking, metadata, learning object repository, RankNet.


In a broad definition, learning objects are any digital document that can be used for learning. Learning Object Repositories (LORs) exist to enable sharing of such resources [ 1]. To be included in a repository, learning objects are described by a metadata record usually provided at publishing time. All current LORs provide or are coupled with some sort of search facility.

In the early stages of Learning Object deployment, these repositories were isolated and only contained a small number of learning objects [ 2]. The search facility usually provided users with an electronic form where they could select the values for their desired learning object. For example, through the early ARIADNE Search and Indexation tool [ 3], a user could select "English" as the language of the object, "Databases" as the subdiscipline, and "Slide" as the learning result type. The search engine then compared the values entered in the query with the values stored in the metadata of all objects and returned those which complied with those criteria. While initially this approach seems appropriate to find relevant learning objects, experience shows that it presents three main problems: 1) Common users (i.e., non-metadata experts) found this query approach too difficult and even "overwhelming" [ 4]. The cognitive load required to express their information need into the metadata standard used in the repository was too high. Metadata standards are useful as a way to interchange information between repositories but not as a user query interface. 2) In order for this approach to work, the metadata fields entered by the indexers need to correspond with the metadata fields used by the searchers. A usability study by Najjar et al. [ 5] found that this is usually not the case. Finally, 3) the high precision of this approach often leads to a low recall [ 6]. Being small repositories, most searches produced no results, discouraging the users.

Given these problems with the metadata-based search, most repositories provided a "Simple Search" approach, based on the success of text-based retrieval exemplified by Web search engines [ 7]. In this approach, users only need to express their information needs in the form of keywords or query terms. The learning object search engine then compared those keywords with the text contained in the metadata, returning all the objects that contained the same words. This approach solved the three problems of metadata-based search: The searchers express their queries as a sequence of keywords, the metadata completeness was not as important as before because the query terms could be matched with any field or even the text of the object, and finally, the recall of the query's results increased. This approach seemed the solution for small repositories. However, working with small, isolated repositories also meant that an important percentage of users did not find what they were looking for because no relevant object was present in the repository [ 4].

Current research in the Learning Object community has produced technologies and tools that solve the scarcity problem. Technologies like SQI [ 8] and OAI-PMH [ 9], enable search over several repositories simultaneously. Another technology, ALOCOM [ 10], decomposes complex learning objects into smaller components that are easier to reuse. Finally, automatic generation of metadata based on contextual information [ 11] enables the conversion of the learning content of Learning Management Systems (LMSs), into metadata-annotated Learning Objects, ready to be stored into an LOR. Although these technologies are solving the scarcity problem, they are creating an inverse problem, namely, abundance of choice [ 12]. The user is no longer able to review several pages of results in order to manually pick the relevant objects. The bias of the search engines toward recall only exacerbates this problem. The final result is that even if a very relevant object is present in the result list, the user still could not find it, again, reducing the perceived usefulness of LORs.

While doing a stricter filtering of results (increasing precision at the expense of recall) could solve the oversupply problem, it could also lead again to the initial problem of scarcity. A proven solution for this problem is ranking or ordering the result list based on its relevance. In this way, it does not matter how long the list is, because the most relevant results will be at the top and the user could manually review them. As almost all search engines use this method, searchers are not only used to work with these sorted lists of results but expect them [ 13]. To help the user find relevant learning objects, Duval [ 12] proposed the creation of LearnRank, a ranking function used to define the relevance of learning objects similarly to how PageRank [ 14] defines the relevance of web pages. Also, in a previous paper [ 15], the authors explore how Contextualized Attention Metadata (CAM) [ 16] could be mined to obtain meaningful information about the relevance of a specific learning object for a specific user and context. This paper provides important progress in this direction, proposing and testing a set of multidimensional relevance ranking metrics. These metrics use external sources of information in addition to what is explicitly stated in the user query to provide a more meaningful relevance ranking than current query-matching implementations. The development of these metrics address three main questions: 1) What does relevance mean in the context of Learning Objects? 2) How do we convert the multidimensional relevance concept into numerical values that could be used for sorting? and 3) Can the proposed metrics outperform current generic ranking practices in LOR search?

The structure of this paper is given as follows: Section 2 analyzes the current state of Learning Object Ranking. Section 3 discusses different dimensions of the relevance concept and how they translate to the context of Learning Object search. These relevance dimensions are used as guidelines in Section 4 to propose and compare a set of metrics that can rank a list of learning objects based on usage and contextual information. Section 5 presents different mechanisms in which these metrics could be combined in a unique rank value. To obtain a rough estimate of the benefit that these metrics could have in a real implementation, an exploratory study, where the metrics are compared against human relevance rankings and existing ranking methods, is presented in Section 6. This experiment also tests the efficacy of the metrics combination. This paper closes with conclusions and opens research questions.

Current Statusof Learning Object Ranking

Current LOR search interfaces already provide ranking functionalities based on generic ranking strategies. In this section, we present three categories of those strategies found in practice and in the literature. The advantages and disadvantages of each one are discussed. Finally, the profile of the ideal ranking strategy for learning objects is contrasted with these approaches.

2.1 Ranking Based on Human Review

Some LORs sort their results mainly by peer evaluation. In the case of MERLOT [ 17] for instance, a special group of expert users has the ability to review the objects and grade the Content Quality, Effectiveness, and Ease of Use. The average of these three grades is considered the rating for the object. Peer reviewers also provide an explanation about the decisions behind the grade. The main advantage of this system is that it provides the searching user with a meaningful evaluation of the overall quality of the object and the possible scenarios where it could be useful. However, there are two main disadvantages of this approach. First, this is a very laborious, manual process. Not surprisingly, in the case of MERLOT for instance, only 10 percent of the objects contained in the repository have been peer-reviewed [ 18] (a more recent value of 12.3 percent was obtained through direct observation). This means that, even if an object is relevant for a user and it is returned in the result list but belongs to the 90 percent of the not peer-reviewed material, the user will probably not find it, as it will be hidden in a deep result page. Even worse, an object that received a low score in the review will still be ranked higher than any other not-rated object regardless of its quality. A solution tried by MERLOT to this problem is to allow users to comment on and rate the objects. While this helps to increase the number of rated objects (circa 25 percent), it is still difficult to reach a majority of objects. Also, the user reviews are less detailed than the peer review, providing less help to the searcher.

The second disadvantage is that a human measurement of quality is static and does not adapt to different users' needs. For example, searching for "databases" in MERLOT will present in the first results highly rated resources for educational databases of content. This answer, while useful for users that are searching other repositories of learning materials, will not help the user that is looking for learning resources about relational databases, such as MySQL or Oracle. A similar approach is taken by Vargo et al. [ 19]. They use the data generated by user's evaluation of the quality of the learning object to sort. Users measure the LO quality using the Learning Object Review Instrument, a set of nine quality parameters that the learning object should meet. The main drawback of this ranking approach is the previously mentioned problem of the lack of scalability of user review.

In summary, using manual review of learning objects for ranking suffers from the same problem of indexing by experts or librarians: in most situations, humans do not scale [ 20]. While normally highly meaningful for the user, this approach will break apart in a projected ecosystem where millions of objects are created everyday. Another perceived problem of manual review ranking is that it cannot be easily adapted to different users or contexts. The recall of the ${\rm top}\hbox{-}k$ elements in the result list tends to be low, as relevant objects will not be evaluated. The precision also varies depending on whether the context of the human evaluator was or not the same as that of the searcher.

2.2 Ranking Based on Text Similarity

A completely different approach is followed by other repositories. We will take SMETE [ 21] as an example. It relies on content-based calculations in order to assign a relevance value to all the objects returned in a search. In the case of SMETE, it calculates the similarity between the query terms and the text contained in the metadata of the learning objects. It uses some variation of vector-space algorithms [ 22]. This algorithm creates a vector for the documents and the query where each dimension is a word. The magnitude of the document or query vector in each word is the frequency of the word in the query divided by its frequency in the whole repository. This is similar to the algorithms used for basic text information retrieval [ 23] and early Web search engines [ 24]. Other examples are presented in the work of Chellappa [ 25] that summarizes the methodology followed by several repositories: adapting full-text search approaches to rank the learning objects based only on the similarity between the query terms and the text fields of the metadata record. This approach, using simple text-based metrics, has the advantage that can be computed easily for each one of the objects in the list. Nonetheless, it presents two main disadvantages. First, the amount of text normally contained in the learning object metadata is low. This leads to equal values for several objects and underperformance compared to the use of the same algorithm against a full-text index. Second, the order of the final list reflects how many times the query words appear on the metadata fields of the object, but it does not transmit to the user any notion about the quality/relevance of the object itself. Fine-grained but very relevant differences between learning objects, for example targeted age group or educational context, are very difficult to be captured by any of the current text analysis/clustering mechanisms. In order to obtain a more meaningful ranking, more contextual information is needed. For example, all current Web search engines make use of ranking algorithms that are heavily based on the analysis of the Web network [ 14] or click-through information [ 26] in order to improve the sorting of the result list.

In summary, using the distance between the text in the metadata and the query terms to rank learning objects, especially using advanced approaches that deal with synonym words such as Latent Semantic Analysis [ 27], leads to high recall. However, using only a text-based approach reduces the precision of the ${\rm top}\hbox{-}k$ results. The lack of additional information to address learning-specific aspects of the relevance ranking makes uncertain that objects in top positions correlate well with the real information need of the learner.

2.3 Ranking Based on User Profile

Olmedilla [ 28] proposes to compare topics provided in the user profile with the classification of the learning object. The closer the values of the profile and the object are in the taxonomy, the higher the relevance of the object. From a theoretical point of view, this approach should lead to a high precision in the ${\rm top}\hbox{-}k$ . However, in practice, this approach presents several handicaps: 1) Users need to explicitly select their interest from a taxonomy before performing the search. 2) It could only be applied to objects that have been classified with the same taxonomy as the one presented to the users.

Personalized ranking based on user profile has, for instance, been implemented in the HCD-Online tool. The personalized ranking of this tool was evaluated by Law et al. [ 29]. The results of the evaluation show that the text-based ranking (based on a Lucene [ 30] index) outperforms any of the personalized rankings. In a similar work, Dolog et al. [ 31] propose a rule-based personalization based on the semantic description of both the user profile and the learning object. The main disadvantage of this approach is that it requires very rich manual metadata annotation of both the user and the object in order to work.

In summary, while the idea of using the profile to personalize the search results works in similar environments [ 32], the way in which it is implemented could lead to unwanted results. Manually generated user profiles usually do not capture the real information need of the user [ 33] as this need is always changing depending on the context of the task that she is performing. The implicit learning of user profiles based on her interactions with the system seems to adapt better to changes in the needs of the user.

2.4 Current Approaches versus Ideal Approach

All current approaches, namely, manually rating the objects, using only document information, or asking the user to provide a profile, have serious disadvantages. The first is not scalable, the second does not carry enough insight on the quality (and thus relevance) of the object, and the third does not integrate well into the normal workflow of the user. To enable a new generation of more useful search facilities for learning objects, an ideal ranking approach should take into account human-generated information (to be meaningful). It should be possible to calculate its value automatically, no matter the size of the repository (to be scalable) and should not require conscious intervention from the user (to be transparent).

Other communities of practice, for example Web search and journal impact, have already developed strategies that approximate the ideal approach. The PageRank [ 14] metric used to rank web pages is scalable. It is routinely automatically recalculated for more than 11.5 billion pages [ 34]. It is also meaningful as usually the top results are the most relevant pages for a query. And, it is also transparent because it uses the information stored in the structure of the already existing Web graph to obtain its value. In the field of Scientometrics, the Impact Factor [ 35] metric calculates the relevance of a scientific journal in a given field. It is automatically calculated from more than 12 million citations, its results are perceived as useful and editors do not need to provide any additional information than the one already contained in the published papers. These two examples prove that the implementation of ranking metrics that are scalable, meaningful, and transparent to the final user is feasible and desirable. Following the ideas that lead to the development of these examples, this paper proposes and evaluates metrics to automatically calculate the relevance of learning objects based on usage and contextual information generated by the interaction of the user with learning object tools.

Relevance Rankingof Learning Objects

The first step to build metrics to rank learning objects by relevance is to understand what "relevance" means in the context of a Learning Object search. Borlund [ 36], after an extensive review of previous research on the definition of relevance for Information Retrieval, concludes that relevance is a multidimensional concept with no single measurement mechanism. Borlund defines four independent types of relevance:

  1. System or Algorithmic relevance that represents how well the query and the object match.
  2. Topical relevance that represents the relation between an object and the real-world topic of which the query is just a representation.
  3. Pertinence, Cognitive, or Personal relevance that represents the relation between the information object and the information need, as perceived by the user.
  4. Situational relevance that represents the relation between the object and the work task that generated the information need.

To operationalize these abstract relevance dimensions, they need to be interpreted for the specific domain of learning object search. Duval [ 12] defined nine "quality in context" or relevance characteristics of learning objects. These nine characteristics can be disaggregated into 11 atomic characteristics. In this paper, we map those characteristics to the dimensions proposed by Borlund. Table 1 presents those characteristics, the dimension to which they were mapped, and a brief explanation of their meaning. For a deeper discussion on the rationale behind those characteristics, we refer to [ 12].

Table 1. Map of Duval's "Quality in Context" Characteristics into Borlund's Relevance Dimensions

Because the relevance characteristics of learning objects deal with the information need of the user and her preferences and context but not on how the query is formulated, they do not map to the algorithmic dimension of relevance.

Those relevance characteristics that are related to "what" the learner wants to learn are mapped into the Topical Relevance dimension. Therefore, the only relevance characteristic mapped in this dimension is the learning goal. For example, if a learner is looking for materials about the concept of inheritance in Object Oriented Programming, the topical relevance of the object is related to how useful the object has been to learners studying courses related to Object Oriented Programming.

The relevance characteristics that are intrinsic to the learner and do not change with place and only slowly with time are mapped into the Personal Relevance dimension. Inside this group are the motivation, culture, language, educational level, and accessibility needs. Further elaborating the previous example, we can imagine that the same learner feels more comfortable with objects in Spanish (her mother tongue) and is more motivated by visual information. The learner will find a slide presentation with graphics and descriptions in Spanish more relevant than a text document in English about the same subject, even if both have been successfully used to explain inheritance in Object Oriented Programming courses.

Finally, those relevance characteristics that deal with conditions and limitations that depend on the learning task, as well as the device, location, and time, are mapped into the Situational Relevance dimension. Continuing the example, if the learner is doing his learning on a mobile device while commuting on the train, she will find more relevant for that context material that could be formatted to the limited screen size.

The information to estimate these relevance dimensions is not only contained in the query parameters and the learning object metadata but also in records of historical usage and the context where the query takes place. It is assumed that this information is available to the relevance ranker. This could seem unrealistic for classical Learning Object search, where the users, usually anonymous, perform their queries directly to the LOR through a Web interface and the only information available is the query terms. On the other hand, new implementations of LMSs, or plug-ins for old implementations such as Moodle [ 37] and BlackBoard [ 38], as well as plug-ins for authoring environments [ 39] enable the capture of information by providing logged-in users with learning objects search capabilities as part of user workflow during the creation and consultation of courses and lessons. Moreover, the development of CAM [ 16] to log the user interactions with different tools in a common format will help with the collection and simplify the analysis of usage and contextual information.

While this interpretation of the relevance concept is exemplified in a traditional or academic learning environment, it is at least as valid in less structured or informal settings such as corporate training or in situ learning, given that the environments used to assist such learning also store information about the user and the context where the search takes place. This information takes the form of personal profiles, preferences, problem descriptions, and previous and required competences.

A ranking mechanism that could measure some combination of the abovementioned learning relevance characteristics should provide the user with meaningfully ordered learning objects in the result list. Section 4 will propose pragmatic metrics that estimate those characteristics based on usage and contextual information in order to create a set of multidimensional relevance ranking metrics for learning objects. While not every characteristic is considered, at least two metrics are proposed for each relevance dimension.

Ranking Metricsfor Learning Objects

To enable learning object search tools to estimate the relevance characteristics described in the previous section, those characteristics should be operationalized as ranking metrics and calculated automatically. The metrics proposed here are inspired on methods currently used to rank other types of objects, for example books [ 40], scientific journals [ 35], TV programs [ 41], and so forth. They are adapted to be calculable from the information available from the usage and context of learning objects. These metrics, while not proposed as a complete or optimal way to compute the real relevance of a learning object for a given user and task, are a first step to set a strong baseline implementation with which the effectiveness and efficiency of more advanced learning-specific metrics can be compared.

The following metrics are grouped according to the Relevance dimension ( Table 1) that they estimate. There are at least two metrics for each dimension describing different methods in which that relevance can be calculated from different information sources. Each metric is described below by 1) the raw data it requires and 2) the algorithm to convert that data into concrete ranking values. Also for each metric, 1) an example is provided to illustrate its calculation and 2) methods to bootstrap the calculation of the metric in a real environment are discussed.

At the end of this section, the metrics are compared and a selection table is provided according to the desired relevance dimension and the information availability.

4.1 Topical Relevance Ranking Metrics

Metrics to estimate the Topical Relevance should establish which objects are more related to what a given user wants to learn. The first step in the calculation of this type of metric is to estimate what is the topic that interests the user. The second step is to establish the topic to which each learning object in the result list belongs. There are several ways in which the first part, the topic that interests the user, can be obtained: the query terms used, the course from which the search was generated, and the previous interactions of the user with the system [ 42]. For the second part, establishing the topicality of the objects, the information can be obtained from the classification in the learning object metadata, from the topical preference of previous learners that have used the object or the topic of courses that the object belongs to. Once the topical need of the user and the topic described by the object are obtained, the Topical Relevance metric is calculated as the distance between the two. The following sections describe three possible Topical Metrics based on different sources of information.

4.1.1 Basic Topical Relevance Metric (BT)

This metric makes two naïve assumptions. The first assumption is that the topic needed by the user is fully expressed in the query. The second assumption is that each object is relevant to just one topic. As a consequence of these two assumptions, the degree of relevance of an object to the topic can be easily estimated as the relevance of the object to that specific query. That relevance is calculated by counting the number of times the object has been previously selected from the result list when the same (or similar) query terms have been used. Defining NQ as the total number of similar queries of which the system keeps record, BT relevance metric is the sum of the times that the object has been selected in any of those queries (2). This metric is an adaptation of the Impact Factor metric [ 35] in which the relevance of a journal in a field is calculated by simply counting the number of references to papers in that journal during a given period of time:

$$selected(o, q) = \left\{\matrix{1, & {\rm if}\;o\;{\rm clicked}\;{\rm in}\;q,{\kern84pt}(1{\rm a})\cr 0, & {\rm otherwise},\hfill{\kern84pt}(1{\rm b})}\right.$$$$BT(o, q) = \sum_{i = 1}^{NQ} distance(q, q_{i}) \ast selected(o, q_{i}).$$


In (1) and (2), $o$ represents the learning object to be ranked, $q$ is the query performed by the user, and $q_{i}$ is the representation of the $i{\rm th}$ previous query. The distance between $q$ and $q_{i}$ can be seen as the similarity between two queries. This similarity can be calculated either as the semantic distances between the query terms (for example, their distance in WordNet [ 43]) or the number of objects that both queries have returned in common. $NQ$ is the total number of queries.

Example. We assume that the query history of the search engine consists of queries $Q_{A}$ , $Q_{B}$ , and $Q_{C}$ . In $Q_{A}$ , objects $O_{1}$ and $O_{2}$ were selected; in $Q_{B}$ , objects $O_{2}$ and $O_{3}$ ; and in $Q_{C}$ , objects $O_{1}$ and $O_{2}$ . A new query is performed, $Q$ , and objects $O_{1}$ , $O_{2}$ , $O_{3}$ , and $O_{4}$ are present in the result list. The distance between $Q$ and $Q_{A}$ is 1 (both are the same query), between $Q$ and $Q_{B}$ is 0.8 (they are similar queries), and between $Q$ and $Q_{C}$ is 0 (not related queries). The BT metric value of $O_{1}$ is equal to $1 \ast 1 + 0.8 \ast 0 + 0 \ast 1 = 1$ ; for $O_{2}$ , it is 1.8; for $O_{3}$ , it is 0.8, and for $O_{4}$ , it is 0. The order of the final result list ranked by BT would be $(O_{2}, O_{1}, O_{3}, O_{4})$ .

Data and initialization. In order to calculate this metric, the search engine needs to log the selections made for each query. If no information is available, the metric assigns the value of 0 to all objects, basically not affecting the final rank. When information, in the form of user selections, starts entering the system, the BT rank starts to boost previous selected objects higher in the result list. One way to avoid this initial training phase is to provide query-object pairs given by experts or obtained from information logged in previous versions of the search engine.

4.1.2 Course-Similarity Topical Relevance Ranking (CST)

In the context of formal learning objects, the course in which the object will be reused can be directly used as the topic of the query. Objects that are used in similar courses should be ranked higher in the list. The main problem to calculate this metric is to establish which courses are similar. A very common way to establish this relationship is described by SimRank [ 44], an algorithm that analyzes the object-to-object relationships to measure the similarity between those objects. In this metric, the relation graph is established between courses and learning objects. Two courses are considered similar if they have a predefined percentage of learning objects in common. This relationship can be calculated by constructing a two-partite graph where courses are linked to objects published in them. This graph is folded over the object partition leaving a graph representing the existing relationships and strengths between courses. The number of objects shared between two courses, represented in this new graph as the number of links between them, determines the strength of the relationship. A graphical representation of these procedures can be seen in Fig. 1. The ranking metric is then calculated by counting the number of times that a learning object in the list has been used in the universe of courses (5). This metric is similar to the calculation made by e-commerce sites such as Amazon [ 40], where additional to the current item, other items are recommended based on their probability of being bought together:

$$present(o, c) = \left\{\matrix{1, & {\rm if}\;o \in c,\hfill{\kern78pt}(3{\rm a})\hskip-31pt\cr 0, & {\rm otherwise}, \hfill{\kern78pt}(3{\rm b})\hskip-31pt}\right.$$$$SimRank(c_{1}, c_{2}) = \sum_{i = 1}^{NO}present(o_{i}, c_{1}) \ast present(o_{i}, c_{2}),$$


$$CST(o, c) = \sum_{i = 1}^{NC}SimRank(c, c_{i}) \ast present(o, c_{i}).$$


In (3), (4), and (5), $o$ represents the learning object to be ranked, $c$ is the course where it will be inserted or used, $c_{i}$ is the $i{\rm th}$ course present in the system, $NC$ is the total number of courses, and $NO$ is the total number of objects.

Fig. 1. Calculation of SimRank between courses for CST.

Example ( Fig. 1). We assume that three courses are registered in the system $C_{1}$ , $C_{2}$ , and $C_{3}$ . Objects $O_{1}$ , $O_{3}$ , and $O_{4}$ are used in $C_{1}$ , objects $O_{2}$ , $O_{4}$ , and $O_{6}$ in $C_{2}$ , and objects $O_{2}$ , $O_{3}$ , $O_{5}$ , and $O_{6}$ in $C_{3}$ . The SimRank between $C_{1}$ and $C_{2}$ is 1, between $C_{1}$ and $C_{3}$ is 1, and between $C_{2}$ and $C_{3}$ is 2. A query is performed from $C_{2}$ and in the result list are the objects $O_{1}$ , $O_{3}$ , and $O_{5}$ . The CST value for $O_{1}$ is $1 \ast 1 + 2 \ast 0 = 1$ ; for $O_{3}$ , it is 3; for $O_{5}$ , it is 2. The order of the final result list ranked by CST would be $(O_{3}, O_{5}, O_{1})$ .

Data and initialization. To apply the CST, the search engine should have access to the information from one or several LMSs, such as Moodle or Blackboard, where learning objects are being searched and inserted. First, it needs to create a graph with the current courses and the objects that they use in order to calculate the SimRank between courses. Second, it needs to obtain, along with the query terms, the course where the query was performed. In a system without this information, the CST will return 0, leaving unaffected the rank of the results. When the first results of insertion are obtained from the LMS, the CST could start to calculate course similarities and therefore ranking for the already used objects. This metric could be bootstrapped from the information already contained in common LMSs or Open Courseware initiatives [ 45].

4.1.3 Internal Topical Relevance Ranking (IT)

If there is no usage information available, but there exists a linkage between objects and courses, the Basic Topical Relevance Rank can be refined using an adaptation of the HITS algorithm [ 46] proposed to rank web pages. This algorithm states the existence of hubs, pages that mostly point to other useful pages, and authorities, pages with comprehensive information about a subject. The algorithm presumes that a good hub is a document that points to many good authorities, and a good authority is a document that many good hubs point to. In the context of learning objects, courses can be considered as hubs and learning objects as authorities. To calculate the metric, a two-partite graph is created with each object in the list linked to its containing courses. The hub value of each course is then calculated as the number of in-bound links that it has. A graphical representation can be seen in Fig. 2. Finally, the rank of each object is calculated as the sum of the hub value of the courses where it has been used:

$$IT(o) = authority(o) = \sum_{i = 1}^{N} degree(c_{i}) \;|\; c_{i}\;{\rm includes}\;o.$$


In (6), $o$ represents the learning object to be ranked, $c_{i}$ represents the $i{\rm th}$ course where $o$ has been used, and $N$ is the total number of courses where $o$ has been used.

Fig. 2. Calculation of Internal Topical Relevance Ranking (IT).

Example ( Fig. 2). We assume that in response to a query, objects $O_{1}$ , $O_{2}$ , $O_{3}$ , $O_{4}$ , and $O_{5}$ are returned. From the information stored in the system, we know that $O_{1}$ is used in course $C_{1}$ , $O_{2}$ , $O_{3}$ , and $O_{4}$ in $C_{2}$ , and $O_{4}$ and $O_{5}$ in $C_{3}$ . The hub value of $C_{1}$ (its degree in the graph) is 1, of $C_{2}$ is 3, and of $C_{3}$ is 2. The IT metric for $O_{1}$ is 1, the hub value of $C_{1}$ . For $O_{2}$ and $O_{3}$ , the value is 2, the hub value of $C_{2}$ . For $O_{4}$ , IT is the sum of the hub values of $C_{2}$ and $C_{3}$ , i.e., 5. For $O_{5}$ , it is 2. The order of the final result list ranked by IT would be $(O_{4}, O_{2}, O_{3}, O_{5}, O_{1})$ .

Data and initialization. The calculation of IT needs information from LMSs. Similarly to CST, IT uses the relationship between courses and objects. On the other hand, IT does not need information about the course at query time (QT), so it can be used in anonymous Web searches. Course-Object relationship can be extracted from existing LMS that contribute objects to the LOR and can be used as bootstrapping data for this metric. An alternative calculation of this metric can use User-Object relationships in case that LMS information is not available.

4.2 Personal Relevance Ranking Metrics

As discussed in Section 3, the Personal Relevance metrics should try to establish the learning preferences of the user and compare them with the characteristics of the learning objects in the result list. The most difficult part in these metrics is to obtain transparently an accurate representation of the personal preferences. The richest source of information about these preferences is the attention metadata that could be collected from the user [ 47]. There are different ways in which this metadata could be used to determine a profile for each user or similarity between users. For example, Mobasher et al. [ 48] presents some strategies to build user profiles from Web access data and Pampalke et al. [ 49] discuss the generation of playlists based on user skipping behavior. The second step in this metric calculation is to obtain the characteristics of the objects. If metadata is present, this process is vastly simplified, because there already exists a description of the characteristics of the object. However, if metadata is not complete or inaccurate, contextual and usage information can be used to automatically generate the desired metadata values [ 11]. The following sections present the calculation of two possible Personal Relevance metrics for learning objects.

4.2.1 Basic Personal Relevance Ranking (BP)

The easiest and least intrusive way to generate user preference information is to analyze the characteristics of the learning objects they have used previously. First, for a given user, a set of the relative frequencies for the different metadata field values present in their objects is obtained:

$$cont(o, f, v) = \left\{\matrix{1, & {\rm if}\;val(o, f) = v, \hfill{\kern91pt}(7{\rm a})\cr 0, & {\rm otherwise},\hfill{\kern78pt}(7{\rm b})}\right.$$$$freq(u, f, v) = {{1}\over{N}}\sum_{i = 1}^{N}cont(o_{i}, f, v)\;|\;o_{i}\;{\rm used}\;{\rm by}\;u.$$


In these equations, $val(o, f)$ represents the value of the field $f$ in the object $o$ . The frequencies for each metadata field are calculated by counting the number of times that a given value is present in the given field in the metadata. For example, if a user has accessed 30 objects, from which 20 had "Spanish" as language and 10 had "English," the relative frequency set for the field "Language" will be $({\rm es} = 0.66, {\rm en} = 0.33)$ . This calculation can be easily performed for each of the categorical fields (fields that can only take a value from a fixed vocabulary). Other types of fields (numerical and free text) can also be used in this calculation if they are "categorized." For example, the numerical field "Duration" that contain the estimated time to review the object can be transformed into categorical clustering the duration values in meaningful buckets: (0-5 minutes, 5-30 minutes, 30 minutes-1 hour, 1-2 hours, more than 2 hours). For text fields, keywords present in a predefined thesaurus could be extracted. An example of this technique is presented in [ 50].

Once the frequencies are obtained, they can be compared with the metadata values of the objects in the result list. If the value present in the user preference set is also present in the object, the object receives a boost in its rank equal to the relative frequency of the value. This procedure is repeated for all the values present in the preference set and the NF selected fields of the metadata standard:

$$BP(o, u) = \sum_{i = 1}^{NF}freq\left(u, f_{i}, val(o, f_{i})\right)\;|\;f_{i}\;{\rm present}\;{\rm in}\;o.$$


This metric is similar to that used for automatically recording TV programs in Personal Video Recorders [ 41]. The metadata of the programs watched by the user, such as genre, actors, director, and so forth, is averaged and compared against the metadata of new programs to select which ones will be recorded.

In (7), $o$ represents the learning object to be ranked, $f$  represents a field in the metadata standard, and $v$ is a value that the $f$ field could take. Additionally, in (8), $u$ is the user, $o_{i}$ is the $i{\rm th}$ object previously used by $u$ , and $N$ is the total number of those objects. In (9), $f_{i}$ is the $i{\rm th}$ field considered for the calculation of the metric and $NF$ the total number of those fields.

Example. We assume that a given learner has previously used three objects: $O_{1}$ , $O_{2}$ , and $O_{3}$ . $O_{1}$ is a Computer Science-related slide presentation in English. $O_{2}$ is a Computer Science-related slide presentation in Spanish. $O_{3}$ is a Math-related text document in Spanish. If the previously mentioned technique is used to create the profile of the learner, the result will be $learner = [Classification(Computer$$Science\! =\! 0.67, Math\! =\! 0.33), LearningResourceType(slide =$$\!0.67, narrative text = 0.33),$$Language(en = 0.33, es = 0.67)]$ . The learner performs a query and in the result list are the objects $O_{4}$ , $O_{5}$ , and $O_{6}$ . $O_{4}$ is a Computer Science-related text document in English, $O_{5}$ is a Math-related figure in Dutch, and $O_{6}$ is a Computer Science-related slide presentation in Spanish. The BP value for $O_{4}$ is $0.67 \ast 1 + 0.33 \ast 1 +\!$$0.33 \ast 1 = 1.33$ . For $O_{5}$ , it is 0.33. For $O_{6}$ , it is 1.66. The order of the final result list ranked by BP would be $(O_{6}, O_{4}, O_{5})$ .

Data and initialization. The BP metric requires the metadata information about the objects previously selected by the users. This Identifier of the user and objects can be obtained from the logs of the search engine (given that the user is logged in at the moment of the search). Once the identifier is known, the metadata can be obtained from the LOR. A profile for each user can be created offline and updated regularly. To bootstrap this metric, the contextual information of the user can be transformed into the first profile. For example, if the user is registered in an LMS, we will have information about his major and educational level. Also, information collected at the registration phase could also be used to estimate user age and preferred language.

4.2.2 User-Similarity Personal Relevance Ranking (USP)

The Basic Personal Relevance Metric relies heavily on the metadata of the learning object in order to be effective. But, metadata is not always complete or reliable [ 51]. A more robust strategy to rank objects according to personal preferences is to find the number of times similar users have reused the objects in the result list. To find similar users, we can apply the SimRank algorithm, previously used to obtain the CST metric. A two-partite graph contains the objects linked to the users who have reused them. The graph is folded over the object partition and a relationship between the users is obtained. The relationship graph is used to calculate the USP metric, as in (11). The final calculation is performed adding the number of times similar users have reused the object. This kind of metric is that used, for example, by and other music recommenders [ 52] who present new songs based on what similar users are listening to; similarity is defined in this context as the number of shared songs in their playlists:

$$hasReused(o, u) = \left\{\matrix{1, & {\rm if}\;o\;{\rm used}\;{\rm by}\;u, \hfill{\kern70.5pt}(10{\rm a})\cr 0, & {\rm otherwise},\hfill{\kern65pt}(10{\rm b})}\right.$$$$UST(u, o) = \sum_{i = 1}^{NU}SimRank(u, u_{i}) \ast hasReused(o, u_{i}).$$


In (10) and (11), $o$ represents the learning object to be ranked, $u$ is the user that performed the query, $u_{i}$ is the representation of the $i{\rm th}$ user, and $NU$ is the total number of users.

Example. We assume that there are four users registered in the system: $U_{1}$ , $U_{2}$ , $U_{3}$ , and $U_{4}$ . User $U_{1}$ has previously downloaded objects $O_{1}$ , $O_{2}$ , and $O_{3}$ ; user $U_{2}$ , objects $O_{2}$ , $O_{3}$ , and $O_{5}$ ; user $U_{3}$ , objects $O_{2}$ , $O_{5}$ , and $O_{6}$ ; user $U_{4}$ , objects $O_{5}$ and $O_{6}$ . User $U_{1}$ performs a query and objects $O_{4}$ , $O_{5}$ , and $O_{6}$ are present in the result list. The SimRank between $U_{1}$ and $U_{2}$ is 2, between $U_{1}$ and $U_{3}$ is 1, and between $U_{1}$ and $U_{4}$ is 0. The USP metric for $O_{4}$ is $2 \ast 0 + 1 \ast 0 + 0 \ast 0 = 0$ ; for $O_{5}$ , it is 3; and for $O_{6}$ , it is 1. The order of the final result list ranked by USP would be $(O_{5}, O_{6}, O_{4})$ .

Data and initialization. The USP metric uses the User-Object relationships. These relationships can be obtained from the logging information from search engines (if the user is logged in during their interactions with the learning objects). The USP does not need metadata information about the learning objects and can work over repositories that do not store a rich metadata description. If no data is available, the metric returns 0 for all objects, not affecting the final ranking. To bootstrap this metric when there is no previous User-Object relationship information, the User-Course and Course-Object relationships obtainable from LMS systems could be used.

4.3 Situational Relevance Ranking Metrics

The Situational Relevance metrics try to estimate the relevance of the object in the result list to the specific task that caused the search. In the learning object environment, this relevance is related to the learning environment in which the object will be used as well as the time, space, and technological constraints that are imposed by the context where the learning will take place. Contextual information is needed in order to establish the nature of the task and its environment. When some description of the context is extracted from this information, it can be used to rank the objects. Again, these characteristics could be extracted from the object metadata or information already captured about the previous usage of the objects. The following sections present two alternative methods to calculate Situational Relevance metrics.

4.3.1 Basic Situational Relevance Ranking (BS)

In formal learning contexts, the description of the course, lesson, or activity in which the object will be inserted is a source of contextual information. Such information is usually written by the instructor to indicate to the students what the course, lesson, or activity will be about. Keywords can be extracted from these texts and used to calculate a ranking metric based on the similarity between the keyword list and the content of the textual fields of the metadata record. To perform this calculation, the similarity is defined as the cosine distance between the TF-IDF vector of contextual keywords and the TF-IDF vector of words in the text fields of the metadata of the object in the result list:

$$BS(o, t) = {{\sum\limits_{i = 1}^{M}tv_{i} \ast ov_{i}}\over{\sqrt{\sum\limits_{i = 1}^{M}tv_{i}^{2} \cdot \sum\limits_{i = 1}^{M}ov_{i}^{2}}}}.$$


The TF-IDF is a measure of the importance of a word in a document that belongs to a collection. TF is the Term Frequency or the number of times that the word appears in the current text. IDF is the Inverse Document Frequency or the number of document in the collection when the word is present. This procedure is based on the vector space model for information retrieval [ 53]. One parallel application of this type of metric has been developed by Yahoo for the Y!Q service [ 54], which can perform contextualized searches based on the content of a web page in which the search box is located.

In (12), $o$ represents the learning object to be ranked, $c$  is the course where the object will be used, $tv_{i}$ is the $i{\rm th}$  component of the TF-IDF vector representing the keywords extracted from the course description, $ov_{i}$ is the  $i{\rm th}$ component of the TF-IDF vector representing the text in the object description, and $M$ is the dimensionality of the vector space (number of different words).

Example. We assume that an instructor creates a new lesson inside an LMS with the following description "Introduction to Inheritance in Java." The instructor then searches for learning objects using the term "inheritance." The result list is populated with three objects. $O_{1}$ has as description "Introduction to Object-Oriented languages: Inheritance," $O_{2}$ has "Java Inheritance," and $O_{3}$ has "Introduction to Inheritance." The universe of words, extracted from the description of the objects would be ("introduction," "inheritance," "java," "object-oriented," "languages"). The TF-IDF vector for the terms in the lesson description is then (1/2, 1/3, 1/1, 0/1, 0/1). For the description in object $O_{1}$ , the vector is (1/2, 0/3, 0/1, 1/1, 1/1). For $O_{2}$ , it is (0/2, 1/3, 1/1, 0/1, 0/1). For $O_{3}$ , it is (1/2, 1/3, 0/1, 0/1, 0/1). The cosine distance between the vector of the lesson description and $O_{1}$ is $(0.5 \ast 0.5 + 0.33 \ast 0 + 1 \ast$$0 +\!$$0 \ast 1 + 0 \ast 1)/ \sqrt{(0.5^{2} + 0.33^{2} + 1^{2}) \,\ast\, (0.5^{2} + 1^{2} + 1^{2})} = 0.14$ . For $O_{2}$ , it is 0.90, and for $O_{3}$ , it is 0.51. The order of the final result list ranked by BS would be $(O_{2}, O_{3}, O_{1})$ .

Data and initialization. To calculate the BS metric, the only information needed is the text available in the context and the object metadata. The text information of the context should be provided at QT. The information needed to bootstrap this metric is a corpus with the text available in the object metadata to provide the value of the IDF of each word.

4.3.2 Context Similarity Situational Relevance Ranking (CSS)

A fair representation of the kind of objects that are relevant in a given context can be obtained from objects that have already been used under similar conditions. For example, if we considered the case where the course represent the context, objects already present in the course are a good representation of what is relevant in that context. Similar to the calculation of the BP metric, the $N$ objects contained in the course are "averaged" to create a set of relative frequencies for different fields of the learning object metadata record:

$$freq(c, f, v) = {{1}\over{N}}\sum_{i = 1}^{N}cont(o_{i}, f, v)\;|\;o_{i}\;{\rm included}\;{\rm in}\;c.$$


This set of frequencies is then compared with the objects in the result list. The relative frequencies of the values present in the object's metadata are added to compute the final rank value:

$$CCS(o, c) = \sum_{i = 1}^{NF}freq\left(c, f_{i}, val(o, f_{i})\right)\;|\;f_{i}\;{\rm present}\;{\rm in}\;o.$$


This method can be seen as creating a different user profile for each context (in this case seen as course) where the learner is involved. This method can be applied to more complex descriptions of context. For example, if query is used during the morning, a frequency profile can be obtained from objects that the learner has used during similar hours in the morning. That "time of the day" profile can latter be used to rank the result list using the same approach presented above. Other contextual descriptors that can be used are place, type of task, access device, and so forth.

In (13) and (14), $o$ represents the learning object to be ranked, $c$ is the course where the object will be used, $o_{i}$ is the $i{\rm th}$ object contained in the course $c$ , $f$ represents a field in the metadata standard, and $v$ is a value that the $f$ field could take. $val(o, f)$ returns the value of the field $f$ in the object $o$ . $f_{i}$ is the $i{\rm th}$ field considered for the calculation of the metric and $NF$ is the total number of those fields. $cont(o, f, v)$ is presented in (7). Here, $N$ represents the number of objects contained in the course.

Example. We assume that a learner issues a query from course $C$ . Course $C$ has three objects $O_{1}$ , $O_{2}$ , and $O_{3}$ . $O_{1}$ is flash animation whose duration is between 0 and 5 min and is for higher education. $O_{2}$ is another flash animation whose duration is between 5 and 10 minutes and is for higher education. $O_{3}$ is a video of 20 minutes and also targeted to higher education. The profile for that specific course will be  $C = [LearningResourceType(animation = 0.67, video =\!\!$$0.33),\;\! Duration(0\hbox{-}5\; {\rm minutes} = 0.33,\;\! 5\hbox{-}10\;{\rm minutes} = 0.33,\; 10\hbox{-}\!$$30\; {\rm minutes} \!=\! 0.33),\;Context(highereducation \!=\! 1)]$ . The result list contains the following objects: $O_{4}$ , a text document with estimated learning time of 1 hour for higher education; $O_{5}$ , a video whose duration is between 0 and 5 minutes, targeted to primary education; and $O_{6}$ , a flash animation whose duration is between 10 and 30 minutes, targeted to higher education. The CSS value for $O_{4}$ is $0 \ast 0 + 0 \ast 0 + 1 \ast 1 = 1$ . For $O_{5}$ , it is 0.66. For $O_{6}$ , it is 2. The order of the final result list ranked by CSS would be $(O_{6}, O_{4}, O_{5})$ .

Data and initialization. The CSS metric depends on the contextual information that can be captured during previous interactions of the user with the learning objects, as well as during QT. The most basic context that can be obtained from an LMS is the course from which the user submitted the query. Also, using the course as the context facilitates to capture the information about previous objects used in the same context, helping in the bootstrapping of the metric. Nevertheless, more advanced context definitions are allowed to calculate variations of this metric, at the cost of a more detailed logging of user actions.

4.4 Ranking Metrics Comparison

Different metrics estimate different relevance dimensions and consume different types of raw data. Therefore, not all the metrics can or should be implemented in different environments. For example, if the searching environment does not include information from an LMS or similar system, some of the metrics (CST and CSS), for example, could not be calculated. This section presents a comparison between the proposed relevance ranking metrics based on their related relevance characteristics and the origin of the data needed for their calculation.

Table 2 presents the correspondence of the ranking metrics with the Relevance or Quality Characteristics presented in Section 3. It can be clearly seen that each metric only covers a small percentage of the characteristics. Also, their correspondence has different levels. A metric can correspond strongly with some characteristics and weakly with others. For example, CST, by its definition, can be used to estimate the Learning Goal of the user. However, given that it is based on the similarity of courses, it is also correlated in a lower level with the Learning Setting (similar courses sometimes use similar learning approaches) and, even a weaker level, with the Language (courses sharing the same objects usually are in the same language) and the Cultural characteristics (the decision to chose similar material could be related to the cultural context). Another interesting example is BT. This metric is based on the metadata of the object that a learner has previously used. While it is designed to estimate the Personal Relevance, the presence on the metadata of contextual-related fields like Duration, Interactivity Type, and Technical Requirements also correlate it with some of the Contextual Relevance characteristics. Some metrics need to be adapted to address different Contextual Relevance characteristics. For example, CSS can be calculated from different types of contextual information to be used to estimate the relevance for different Learning Settings, Times, or Spaces.

Table 2. Correspondence of the Ranking Metrics with the Quality Characteristics and Relevance Dimensions

Table 2 also shows that the proposed metrics as a whole correspond with most of the relevance characteristics. However, Learner Motivation and the Contextual characteristics are not well covered. This is a reminder that the proposed metrics are not a comprehensive set but a first formal proposal of multidimensional relevance ranking metrics for learning objects.

The implementation of the metrics in real systems is bound to be dependant to the availability of the raw data for their calculation. Table 3 presents a summary of the data needed for the different metrics. It is important to note that some data are required at Query Time (QT), for example, the user identification in the Personal Relevance metrics. Other information is needed for offline (OL) calculations, for example, the similarity between queries used in BT metric can be precalculated from the Query-Object Relationship. As expected, all metrics rely in usage and contextual information provided by an LMS or the capture of CAM. If only information from an LMS is available, the best metrics to cover most of the relevance dimensions will be CST, IT, and BS. If the system is not connected to an LMS but has CAM from the users, then BT, BP, and USP are the most appropriate metrics.

Table 3. Source Data Needed to Calculate the Ranking Metrics

All the metrics need some sort of OL calculation. Even BT, which only use terms in the context and terms in the text of the object, needs to have an index with the frequency of different words in order to be calculated. Any system that implements those metrics is bound to provide some kind of temporal storage. Moreover, depending on the scale of data collection, the solutions for data storage and processing could be the principal concern in the metric calculation system.

In summary, the different origin and target of the ranking metrics make them strong when they are seen as a group but weak if they are taken alone. That is the reason why metrics in real-world search engines are combined in order to provide a final rank. Section 5 will discuss the different methods to combine all the proposed ranking metrics into a unique LearnRank estimation.

Learningto (Learn)Rank

In order to be useful, the different metrics should be combined to produce a unique ranking value that could be easily used to order result lists. This combination of metrics is not a trivial task. A series of workshops, entitled "Learning to Rank" [ 55], has been conducted in recent years to discuss and analyze different methods to combine metric values to produce a final, optimal ranker. All these methods share a similar approach:

  1. Obtain human-generated values of relevance (explicitly or implicitly) for different result lists.
  2. Calculate the metrics for the same objects.
  3. Use the metrics values as input and the human-generated relevance values as output to train some machine learning algorithm.
  4. Use the resulting trained machine learning model as the final ranking metric.

The most basic approach to learn a ranking function based on numerical metrics is multivariable linear regression [ 56]. In this approach, the human ranking is considered the dependent variable and all the ranking metrics are the independent variables. The coefficients that produce the best fit of the learned function against the human-generated relevance values are estimated. The final function takes the form of a linear combination of the metrics. While simple, the main problem with this approach is that it overconstrains the problem to solve. We want to learn the order in which objects should be ranked, not the actual value assigned to each object [ 57]. More advanced approaches do not use the numerical value of human relevance estimation as the target for learning but only the relative position on the human-generated rank. The machine learning algorithm is trained to rank the objects in the same order as a human would do, without caring about the individual rank values. These approaches have shown to be much more effective [ 58].

To generate LearnRank, a metric that combines the different relevance metrics to rank learning objects, this paper will use one of the order-based learning strategies. The selected algorithm was RankNet [ 57]. The selection was based on the effectiveness of this algorithm [ 59], as well as its commercial success (it is the rank learn algorithm behind MSN Search). RankNet uses a neural network to learn the optimal ranking based on the value of the original metrics. The training is conducted using pairs of results ranked with respect to each other. The Neural Net is trained to produce the smallest amount of error with respect to the training pairs (cost function). For example, if it is known that R1 should be ranked higher than R2 and the neural network output indicates that LearnRank(R2) is higher than LearnRank(R1), a corrective coefficient is backpropagated to adjust the weight of the neurons of the Net. The best set of coefficients is selected based on the ones that produce the lower difference between the calculated and human-based ordering. More details about the properties of RankNet algorithm are presented in [ 57]. The main advantage of using a learning mechanism based on relative relevance is that the human-generated relevance data needed to learn and improve the ranking can be automatically extracted from the interactions of the users with the search (or recommendation) tool. It has been demonstrated that users review the result list from the first to the last item in order [ 26]. Therefore, the position of the object selected gives information about the relative relevance of it against previous objects. For example, if a user confronted with a result list selects the third object only, it means that she considered it of higher relevance than the first and second objects. That information could be converted to relative relevance pairs that could be fed into the RankNet algorithm in order to improve the ranking. The next time that the user is confronted with the same result list, the third object should be in a higher position.

Evaluation Experiment

In order to evaluate the potential impact that the proposed metrics could have on the relevance ranking of learning object searches, an exploratory study has been performed. This study consisted of an experiment in which subjects were asked to simulate the creation of a lesson inside an LMS. The subjects were required to quantify the relevance of a list of top-10 learning objects, ranked using the default text-based TF-IDF metric provided in Lucene [ 30]. They also had to select from the list objects they considered appropriate for the lesson. The TF-IDF metric is compared with the subject's ranking to create a baseline performance score. The proposed basic metrics for each one of the relevance dimensions, as well as the best-fitting linear combination and trained RankNet are then used to reorder the list. Finally, the reordered lists are compared against the human-generated rank.

6.1 Experimental Setup

Ten users, eight professors, and two research assistants from the Computer Science field were required to create 10 lessons related to different computer science concepts presented in Table 1. In each lesson, the subjects were required to write a brief description of the lesson for hypothetical students. The subject was then presented with a list of 10 objects. These objects were obtained from an LOR containing all PDF learning objects currently available in the MIT OCW website [ 60] (34,640 objects). The objects belong to all the majors taught at MIT, not only to Computer Science. This LOR was queried with a different query phrase for each lesson, as listed in Table 4. The title, description, and keyword fields were text-matched with the query terms. The top-10 objects of each result list were used in the experiment. The subject then graded the relevance of each object to the lesson, to which end they used a seven-value scale, from "Not relevant at all" to "Extremely Relevant." Moreover, subjects were required to select the objects they would include in the lesson. The data recollection was conducted using a Web application.

Table 4. Task Performed during the Experiment and Their Corresponding Query Phrase

The initial rank of the objects was performed by the Lucene ranking algorithm, which is based on vector space retrieval [ 30]. This algorithm can be considered a good representation of current algorithmic relevance ranking. The basic topical relevance metric (BT) was calculated by counting the number of times each object was selected to be included in the lesson. The selection of each subject was left out for his individual relevance evaluation. The basic personal relevance metric (BP) was calculated using historical information about the objects that the subjects had published in their LMS courses. Three fields were captured: main discipline classification, document type, and context level. These fields were selected on the basis of information available in the LOM record of the MIT OCW learning objects and the metadata available from objects previously published by the participants. The specific course of previous objects was not taken into account because the participants not necessarily teach the experimental topics. The basic situational relevance ranking (BS) captured the text fed by the subjects into the description of the lesson. Any stopwords were eliminated and the resulting keywords were used to expand the query made to Lucene. The revised 10 objects were extracted then from the new result list.

Once the values of the metrics were calculated, they were combined. In order to have into the combination a metric from each one of the relevance dimensions, the relevance score provided by Lucene was used as an estimate of the Algorithmic relevance. Two methods were used to obtain the combination of the metrics: First, the assigned human relevance was used to compute the coefficients of the linear combination of the metrics through multivariable linear regression. This combination will be referenced as "Linear Combination." Second, the relative relevance pairs, also generated as a result of the human ranking, were used to train a two-layer RankNet with 10 hidden neurons. The values of the different metrics were used as the input of the neural net. This combination will be referenced as "RankNet Combination."

In order to avoid overfitting the combined metrics, the training-testing was conducted using a 10-fold approach. The human-generated rank data were divided in 10 sets according to the reviewer to which it belonged. The learning algorithm was trained with nine of the sets and tested in the remaining set. The results reported in this experiment are the ones obtained in the test phase.

Once all the metrics and the two combinations were calculated, they were compared against the manual rank performed by the human reviewers. In order to measure the difference between the manual rank and each of the automated ranks, a variation of the Kendall tau metric [ 61], which deal with ties in the rank, was used. This metric measures the distance between two permutations and is proportional to the number of swaps needed to convert one list into the other using bubble sort. If two ranks are identical, the Kendall tau is equal to 0, and if they are in inverse order, Kendall tau is equal to 1.

6.2 Results

Only 12 percent of the objects presented to the users were manually ranked "Very Relevant" (5), "Highly Relevant" (6), or "Extremely Relevant" (7). This implies that pure algorithmic relevance ranking does a mediocre job at providing relevant results to the user in the top-10 positions of the result list, especially if the repository contains a large amount of objects in different topics. Some searches, for example, "human-computer interaction" return almost only "Not Relevant at All" results, even if in the repository there were material for courses about Interface Design and Human Centered Computing. This was due to the fact that several unrelated objects in the test repository contained the words "human," "computer," and "interaction."

The Kendall tau distance between the Base Rank (based on the Lucene algorithmic relevance metric) and the human ranking has a mean value of 0.4 for all the searches. For query terms that are common to appear in other disciplines besides Computer Science such as "trees" (5) and "human-computer interaction" (6), it borders 0.5. This means that there is no relation between the relevance given by the automatic ranker and the human review. For example, the Lucene algorithm considered of high relevance objects about the biological evolution of natural trees. However, for very specific Computer Science query terms, such as "xml" (6) and "operating systems" (7), it provides a lower value, 0.3, implying a stronger correlation between manual and automatic ranks. These tau values are consistent with the low quality of the retrieval.

If the top-10 results provided by Lucene are reordered using the basic metrics, topic relevance metric (BT) provides the best ranking, with an improvement of 31 percent over the Lucene ranking. The situational relevance ranking (BS) provide an improvement of 21 percent. The less performing metric was the personal relevance (BP), but it alone still produces an improvement of 16 percent over the baseline ranking. If the metrics are combined, the Rank Net combination produces a much better result than the Linear Combination and any of the individual metrics with an improvement of 51 percent over the Lucene ranking. The Linear Combination, on the other hand, produces a result (22 percent) comparable with the ones of the individual metrics. The summary of the results, as well as their statistical significance, can be seen in Table 5. Figs. 3 and 4 show the disaggregated tau values for each one of the queries for the individual and combined metrics.

Table 5. Results of the Evaluation of the Basic Metrics

Graphic: Fig. 3. Results of the Kendall tau distance from the manual ranking of the individual metrics.

Figure    Fig. 3. Results of the Kendall tau distance from the manual ranking of the individual metrics.

Graphic: Fig. 4. Results of the Kendall tau distance from the manual ranking of the combined metrics.

Figure    Fig. 4. Results of the Kendall tau distance from the manual ranking of the combined metrics.

6.3 Discussion of the Results

The basic topic relevance metric (BT) provides the best correlation with manual ranking of the individual metrics. It was the metric most directly related to human choice, as normally highly relevant items were selected for inclusion in the lessons. It performed better than the baseline ranking in all the searches. However, this result has been affected by the fact that all the subjects participating in the experiment belong to the same field. In a real situation, a lower performance is expected as noise is present in the data used to calculate this metric. This noise comes from unrelated searches using similar query terms. For example, if a biology professor was also using the same search engine, it is expected that the query term "tree" produce two different patterns of selections. This problem can be solved by applying a more advanced Topical Relevance, such as CST.

The basic personal relevance metric (BP) presented some problems in certain queries. This can be explained as errors or unexpected values in the metadata records of the objects. While the object was relevant for a given lesson, metadata values do not always match user preferences. For example, in search number 10 ("routing"), the topical classification of the objects was "Electrical Engineering," different from the "Computer Science" value that all the subjects had in their profile. Another case that exemplifies this problem was present in search number 1 ("inheritance"). The objects found more relevance came from a Programming course of the Civil Engineering department. This value was different from the value present in the subject's profile. This problem could be addressed by measuring the distance between different metadata values instead of the current Boolean comparison. An interesting method to measure this distance using classification ontologies is proposed by Olmedilla [ 28].

Basic situational relevance metric (BS) provided an improvement over the baseline rank in all but one search. It performed better for ambiguous query terms (note search numbers 4 and 5) while almost not affecting the performance of very specific query terms (searches 6 and 7). This result was expected given similar studies on query expansion using contextual descriptions [ 62].

By far, the best performance was obtained by the RankNet Combination of the metrics. It outperformed the baseline ranking and all the other rankings in most of the searches. However, given that it is still a combination of the metrics, it is bound to underperform individual metrics in specific situations, especially when all the metrics provide a very similar ranking. The clearest example of this effect is the tau value obtained for the "operating system" (case 7). In this case, all the metrics provide a similar tau value. The neural network does not have sufficient input information to produce a better ranking. The Linear Combination, on the other hand, behaves like an average between the individual metrics. It is better than the baseline and the BP, but it is worse than BT. The use of this linear regression is not recommended to learn the ranking function.

In conclusion, the combination of the ranking using RankNet provides a significant increase in the performance of the ranking compared with the baseline Rank (Lucene text-based ranking). These results suggest that a full-fledged implementation of these metrics in a real environment, learning from the continuing interaction of the users with the system, will lead to a meaningful, scalable, and transparent way to rank learning objects according to their relevance for a given query, topic, user, and context.

6.4 Experiment Limitations

Given its exploratory nature, the experiment has several limitations that are being taken into account. The two most important are: 1) Reordering of the same objects. Only objects present in ${\rm top}\hbox{-}k$ results of the algorithmic relevance search were used. The reason for this choice was to limit the amount of manual relevance ranking needed. This limitation, nonetheless, does not affect the result of the evaluation for two reasons. First, the evaluation only compares relative ordering and not absolute relevance score. Second, the bias introduced works against the proposed metrics as they were not able to bring more relevant results from the post-10 objects. Given that the results show that the metrics outperformed the baseline rank, the elimination of this bias will only reinforce the conclusion and 2) limited subject variety. All the subjects were selected from the same field and had similar teaching styles. While this homogeneity boost the result of the basic topical metric because of the absence of noise in the data, it can also be seen as the result of applying a filtering based on user topic preference before calculating BT. Future evaluation in a real system should work with a multidisciplinary sample.


The main contribution of this paper is the development and evaluation of a set of metrics related to different dimensions of learning object relevance. The conclusions of this paper can be summarized in the following points:

  • Information about the usage of the learning objects, as well as the context where this use took place, can be converted into a set of automatically calculable metrics related to all the dimensions of relevance proposed by Borlund [ 36] and Duval [ 12]. This information can be obtained implicitly from the interaction of the user with the system.
  • The evaluation of the metrics through an exploratory study concludes that all the proposed basic metrics outperformed the ranking based on pure text-based approach. This experiment shows that the most common of the current ranking methods is far from optimal, and the addition of even simple metrics could benefit the relevance of the results for LOR's users.
  • The use of methods to learn ranking functions, for example RankNet, leads to a significant improvement of more than 50 percent over the baseline ranking. This result is very encouraging for the development of ranking metrics for learning objects, given that this improvement was reached with only four metrics as contributors to the ranking function.

The metrics proposed here have the characteristics needed by the theoretical LearnRank. The very nature of the presented metrics and their combination makes them scalable. They consume information implicitly collected through attention metadata, making them transparent for the user. Finally, the results of the experiment suggest that they are good estimators of the human perception of the relevance of the learning object, making them at least more meaningful than text-based algorithms. Even if not proposed as an optimal solution, these metrics could be used to improve current LORs. More important for this field of research, these metrics could be considered the new baseline against which new, more advanced metrics could be compared.

The main task left for further work is to execute an empirical study with both a full implementation of the metrics and real. Once there is enough data collected, the user interaction with the system and the progress of the different metrics could be analyzed to shed light on these questions. We also hope that other researchers start proposing improvements to this initial approach.


This work was supported by the cooperation agreement between FWO (Belgium) and Senacyt (Ecuador) under the project "Smart Tools to Find and Reuse Learning Objects."


About the Authors

Bio Graphic
Xavier Ochoa received the degree in computer engineering from Escuela Superior Politécnica del Litoral (ESPOL), Guayaquil, Ecuador, in 2000 and the master's degree in applied computer science from Vrije Universiteit Brussel, Brussels, in 2002. He is an associate professor in the Faculty of Electrical and Computer Engineering, ESPOL, where he coordinates the research group on technology-enhanced learning at the Information Technology Center (CTI). His main research interests revolve around measuring the learning object economy and its impact in learning.
Bio Graphic
Erik Duval is a professor in the research unit on Hypermedia and Databases, Department of Computer Science, Katholieke Universiteit Leuven, where he teaches courses on human-computer interaction, multimedia, problem solving, and design. His current research interests are metadata in a wide sense, learning object metadata in particular, and how they enable finding rather than searching; global learning infrastructure based on open standards; human-computer interaction in general, and in a learning or digital repository context in particular, so that we can "hide everything but the benefits." He serves as a copresident of the ARIADNE Foundation, the chair of the IEEE LTSC working group on learning object metadata, and a member of the Scientific and Technical Council of the SURF Foundation. He is a fellow of the Association for the Advancement of Computers in Education (AACE) and a member of the ACM and the IEEE Computer Society.
59 ms
(Ver 3.x)