Abstract:
The invention is a process for collaborative filtering of information called Time-Space Filtering (TSIF). The invention is used in the fields of information filtering and publishing and is particularly useful in the field of providing web-based information, e.g. electronic newspapers. TSIF is a process of filtering and ranking the relevance of an article&#39;s content to specific readers, taking into account the time dimension of information as well as the factors traditionally considered by content-based or collaborative filtering.

Description:
FIELD OF THE INVENTION 
       [0001]    The invention is related to the fields of information filtering and publishing. Specifically the invention relates to the field of providing web-based information, e.g. electronic newspapers. More specifically the invention relates to a process of filtering and ranking the relevance of an article&#39;s content to specific readers, taking into account the time dimension of information as well as the factors traditionally considered by content-based or collaborative filtering. 
       BACKGROUND OF THE INVENTION 
       [0002]    With the exponential growth of available information, and the rapid changes occurring in most areas of life, most of today&#39;s information becomes non-relevant as time passes. Information with strong dependency between its relevancy and the time dimension is referred to herein as Time-Constrained Information (TCI). An example for TCI is the News domain. 
         [0003]    The following example is given to illustrate and provide an intuitive understanding of the problem that must be overcome if a web based information service of any type is to be able to provide information personally relevant to each of its subscribers: 
         [0004]    Nancy is subscribed to an information service that publishes hundreds of news articles every day. Since Nancy&#39;s time is limited, she would like to receive only twenty articles every time she visits the service web site. She wants these twenty articles to be the most relevant articles to her current interests. Recall that news articles may become irrelevant in a relatively short period of time, say between a few hours and a few days. 
         [0005]    Assume that Nancy is requested to manually rank the hundreds of articles according to relevancy to her interests without having to read the entire articles, and assume that the following two “resources” are available to her:
       1. The opinion of other subscribers about these articles, especially subscribers with similar interests to hers (as defined by similarity of opinions about articles they read in the past); and   2. The content-based profile of each article, e.g. article topic, descriptive keywords, author, etc.       
 
         [0008]    In the art ranking the relevance of articles based on resource 1 is known as collaborative filtering and ranking the relevance of articles based on resource 2 is known as content-based filtering. 
         [0009]    As evident from common sense and supported by studies related to information filtering, the best filtering result will be obtained by using both of these resources. On one hand, Nancy would want to read an article with a content-based profile that matches her interests. On the other hand, her time is limited, there may be many articles whose profiles seem to “match” with her interests but are really not that good or interesting, because the articles&#39; profiles may not accurately represent their actual context (considering well-known limitations of ambiguity of terms used to represent items and users&#39; interests, text-extraction and indexing algorithms). Nancy would like to base her decision regarding what to read also on the opinions of other subscribers who have similar interests. It is reasonable to assume that Nancy&#39;s consideration relevance of the article will increase as more other readers who are similar to her will read that article. 
         [0010]    In order to find the optimal combination between content-based filtering and collaborative filtering, two questions need to be addressed: 
         [0011]    The first question is how much “weight” should be given to the opinions of others about the article (collaborative filtering) compared to the “weight” given to the article&#39;s profile (content-based profile)? There are two factors that should be considered:
       1. The similarity/match between the document&#39;s profile to the user&#39;s profile: the stronger the match, the less important are the other users&#39; opinions; and   2. The age of the article: a user may prefer to read an article even if it has only a few user opinions, rather than wait for more opinions and facing the risk that the article becomes obsolete and even disappear from the system.       
 
         [0014]    The second question is to which opinions should a user give high consideration? In this case also two factors should be considered for each opinion:
       1. How similar are the user&#39;s interests to the interests of the other person who gave the opinion? A user will give higher weight to the opinion of people with similar interests to his/hers;   2. How recent are the opinions? A user will give higher weight to more recent opinions; an article might have been interesting to someone at a certain time, but of no interest a few hours later.       
 
         [0017]    Hence, it is clear that for effective filtering of TCI, relevancy of an article should be based on its content, on other/similar users&#39; judgments, and on the time dimension. The time dimension should be considered both for determining the relative importance of other users&#39; opinions (how “fresh” are their opinions), and for determining the “weight” that should be given to other peoples&#39; opinions compared to the “weight” given to the article&#39;s content-based profile: the older an article, the more likely it is to be ranked according to other peoples&#39; opinions. 
         [0018]    Currently used filtering algorithms neglect the time dimension of information; they base their results on proximity calculations in a “content space” (either directly by content-based filtering or indirectly by collaborative filtering). 
         [0019]    It is therefore a purpose of the present invention to provide an algorithmic framework for filtering time-constrained information that adds the time dimension to content-based and collaborative filtering; thereby providing effective filtering of time constrained information. 
         [0020]    Further purposes and advantages of this invention will appear as the description proceeds. 
       SUMMARY OF THE INVENTION 
       [0021]    In a first aspect the invention is a process for collaborative time-space filtering of information. The process of the invention comprises the following steps:
       Step 1: receiving a request to provide a relevancy-ranked list of items for user X;   Step 2: using a content-based filter to rank the items in the repository for user X;   Step 3: using a time-dependant collaborative filter to rank the items in the repository for user X;   Step 4: computing time-dependant weights for combining the rankings from steps 2 and 3: and   Step 5: computing the overall ranking of the items by using the time-dependant weights to combine the two rankings.       
 
         [0027]    The process of the invention is suited for filtering web based information. In a n embodiment the web based information is used to publish an electronic newspaper. 
         [0028]    In an embodiment of the invention, the content-based filter ranks the items in the repository for user X based on the degree of similarity/match between user X&#39;s profile and the profile of each item. The time-dependant collaborative filter can rank the items in the repository for user X by taking into consideration the following assumptions:
       a. that recent user opinions have a bigger influence on the ranking than older opinions; and   b. that opinions from users similar to user X have a bigger influence on the ranking than opinions from less-similar users       
 
         [0031]    The time-dependant weights for combining the two rankings can be computed assuming that the weight of the collaborative filter is higher for older items. In an embodiment of the process of the invention, the collaborative filter compiles a User&#39;s Collaborative Profile comprising for each item:
       a. a unique identifier of each item recommended to the user in the past;   b. a time-stamp of the time the item was recommended to the user; and   c. an indicator for the user&#39;s opinion of the item.       
 
         [0035]    The collaborative filter uses the User&#39;s Collaborative Profile to compute a User Similarity Score for user X with each user J in the user repository. In an embodiment of the process, only the profiles accumulated over a selected period of time are compared instead of comparing the entire list of collaborative profiles of the users. 
         [0036]    In the process of the invention, the collaborative filter ranks all the items by computing for each item k a value, which is the relative score given to the item, based on other users&#39; recommendations. The weight of a recommendation from user J to item k is discounted according to the time that has passed since the recommendation. Different information types can receive different discounting factors. The time-dependant weight can be used to combine the two rankings by giving a bigger weight to the collaborative filter&#39;s ranking for older items. In an embodiment of the process of the invention, the process removes obsolete items from the items repository and archives them. 
         [0037]    In another aspect the invention is a filtering engine comprising conventional hardware including input/output devices, memory modules, and servers, configured to collect and process the required information according to the steps of the process of the invention. The components of the filtering engine are configured to form the following main modules: the collaborative filter module, the rankings combination module, the update the collaborative filter module, and, the remove decayed items module. 
         [0038]    The purpose of the collaborative filter module is to arrange a list items into a ranked list. The purpose of the rankings combination module is to combine the rankings for the content-based filter and the collaborative filter. The purpose of the update the collaborative filter module is to update the profile of a user after the user was presented with an item The purpose of the remove decayed items module is to determine when an item became obsolete and define it as Archived. 
         [0039]    All the above and other characteristics and advantages of the invention will be further understood through the following illustrative and non-limitative description of preferred embodiments thereof, with reference to the appended drawings. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0040]      FIG. 1  shows examples of Time(J, k) graphs with different discounting factors; 
           [0041]      FIG. 2  schematically illustrates the control flow of the collaborative filter; 
           [0042]      FIG. 3  schematically illustrates the control flow of the rankings combination module; 
           [0043]      FIG. 4  schematically illustrates the control flow of the update the collaborative profile module; and 
           [0044]      FIG. 5  schematically illustrates the control flow of the update the remove decayed items module. 
       
    
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS 
       [0045]    The invention is a process for collaborative filtering of information called Time-Space Filtering (TSIF). The process is especially useful for use by suppliers of web based information, e.g. electronic newspapers. The process of the invention is comprised of the following main steps.
   Step 1: Get a request to provide a relevancy-ranked list of items for user X. A request may come from a user who asks the system to submit/send him new items to read (“pull” mode), or from the system which initiates the distribution of relevant items to subscribed users (“push” model).   Step 2: Use a content-based filter to rank the items in the repository for user X. This is based on the degree of similarity/match between user X&#39;s profile and the profile of each item.   Step 3: Use a time-dependant collaborative filter to rank the items in the repository for user X. This filter considers the assumptions that recent user opinions have a bigger influence on the ranking than older opinions, and that opinions from users similar to user X have a bigger influence on the ranking than opinions from less-similar users   Step 4: Compute time-dependant weights for combining the two rankings (from steps 2 and 3). The weight of the collaborative filter is higher for older items i.e., items which have been available longer in the repository, and vice versa.   Step 5: Computed the overall ranking of the items by using the time-dependant weights to combine the two rankings.   
 
       The Content-Based Filter 
       [0051]    There exist several different content-based (CB) filters which can be used in step 2 of the present invention. One such CB filter is disclosed in Co-pending Israeli Patent Application IL183391 by the same applicant, entitled “Ontology-Content-Based Filtering Method For Personalized Newspapers” the description of which, including publications referenced therein, is incorporated herein by reference. 
         [0052]    Precise knowledge of the CB filter is not important to the remainder of this description; it is only necessary to assume that a CB filter exists that can compute the similarity between a user&#39;s profile and an item&#39;s profile In the second step, the CB filter ranks the relevant items according to how similar they are to the user&#39;s profile, and returns a ranked list of items notated &lt;CB&gt;. 
       The Collaborative Filter 
       [0053]    The next (third) step in TSIF is ranking of the items with the time-space collaborative filtering algorithm This filter derives its recommendations not only according to the “similarity” between users but also according to the time proximity i.e., it gives a higher weight to more recent recommendations. 
         [0054]    The collaborative filter makes use of a User&#39;s Collaborative Profile, which is a table with three columns:
       Column 1 is a unique identifier of each item recommended to the user in the past;   Column 2 is a time-stamp of the time the item was recommended to the user; and   Column 3 is a 0\1 indicator for the user&#39;s opinion of the item: 0 stands for “not interesting”; 1 stands for “interesting”.       
 
         [0058]    The collaborative filtering algorithm computes the User Similarity Score USS(X, J) for user X with each user J in the user repository: The User Similarity Score is computed using the following formula: 
         [0000]    
       
         
           
             
               USS 
                
               
                 ( 
                 
                   X 
                   , 
                   J 
                 
                 ) 
               
             
             = 
             
               Max 
                
               
                 { 
                 
                   Min_Value 
                   , 
                   
                     
                       Mutual 
                        
                       
                         ( 
                         
                           X 
                           , 
                           J 
                         
                         ) 
                       
                     
                     
                       
                         [ 
                         
                           
                             N 
                              
                             
                               ( 
                               X 
                               ) 
                             
                           
                           + 
                           
                             N 
                              
                             
                               ( 
                               J 
                               ) 
                             
                           
                         
                         ] 
                       
                       × 
                       
                         1 
                         2 
                       
                     
                   
                 
                 } 
               
             
           
         
       
     
       Where: 
       [0000]    
       
         
           
             Mutual(X, J)=Number of items that both user X and user J deemed as interesting (both users clicked on these items); 
             N(X)=Number of items in User X collaborative profile; 
             N(J)=Number of items in User J collaborative profile; and 
             Min_Value=default value greater than 0 but smaller than any other USS (e.g. 0.01). 
           
         
       
     
         [0063]    The higher the USS the more similar the two users are. The rationale for computing USS is that the similarity between users can be induced from the number of items they both deemed as interesting. However, this needs to be normalized. (Note: Min_Value will be explained hereinbelow.) 
         [0064]    For example: If the similarity between user X and user J is compared to the similarity between user X and user K, and in both cases the number of mutual items is the same, then user X is said to be more similar to the user with the smaller number of items in his profile (because it is “harder” to find the same number of mutual items in a smaller list). It is to be noted that, instead of comparing the entire collaborative profiles of the users, i.e. a list of all the items the users received in the past, it may be beneficial to compare the profiles accumulated over only a recent period of time, e.g. the last 30 days. The optimal time window for comparing the profiles will be determined for each application. 
         [0065]    The next stage of Step 3 is to use the collaborative filter to rank all the items. To accomplish this the collaborative filter computes for each item k a value notated CFR(k), which is the relative score given to the item, based on other users&#39; opinions: 
         [0000]    
       
         
           
             
               CFR 
                
               
                 ( 
                 k 
                 ) 
               
             
             = 
             
               
                 
                   ∑ 
                   j 
                 
                  
                 
                   [ 
                   
                     
                       USS 
                        
                       
                         ( 
                         
                           X 
                           , 
                           J 
                         
                         ) 
                       
                     
                     × 
                     
                       Time 
                        
                       
                         ( 
                         
                           J 
                           , 
                           k 
                         
                         ) 
                       
                     
                   
                   ] 
                 
               
               
                 Users 
                  
                 
                   ( 
                   k 
                   ) 
                 
               
             
           
         
       
     
       Where: 
       [0000]    
       
         
           
             j=An index for all the users who were presented with item k; 
             USS(X, J)=the computed User Similarity Score between user X and user J; 
             Time(J, k)=a time-adjusting weight (described hereinbelow); and 
             Users(k)=the number of users that were presented with item k (click or no click). 
           
         
       
     
         [0070]    The range of CFR is 0 to 1, with 1 corresponding to the highest rank.
       Using CFR(k), the filter sorts all the items into a vector notated &lt;CF&gt;. Items with high CFR get higher index positions.   Each item k in the vector has a value CF-Rank(k) that is equal to its vector index (starting from 0). For example, if item k is the 3rd item in &lt;CF&gt; then CF-Rank(k)=2       
 
         [0073]    Time (J, k) discounts the weight of a recommendation from user J to item k according to the time that has passed since the recommendation. Several alternatives for computing this factor are possible. For example, if it is assumed that there is an exponential decline of relevancy; Time (J, k) might be expressed as: 
         [0000]      Time ( J, k )=1 /êat    
         [0074]    Where: t=Number of hours since user J indicated interest in item k, and a=constant to be decided based on trial and error. 
         [0075]    In this example: if a=0.1 then:
   After 1 hours Time (J, k)=0.9   After 2 hours Time (J, k)=0.8   After 5 hours Time (J, k)=0.6   After 24 hours Time (JS, k)=0.1   
 
         [0080]    Several Time (J, k) vs. t (in hours) graphs are presented in  FIG. 1 , as examples, with different values for the discounting constant a. In  FIG. 1 , graph x is for a=0.1, graph y for a=0.05, and graph z for a=0.01. In addition to determining the most suitable time discounting method for a particular application, it seems intuitive that different information types will require different discounting factors. For example, a news article may lose relevancy much faster than a book review article. 
         [0081]    In step four of the process of the invention time-dependant weights for combining the two rankings from steps 2 and 3 are computed. The time-dependant weight is designated herein as Maturity(k). This weight is used to combine the two rankings by giving a bigger weight to the collaborative filter&#39;s ranking for more “mature”, i.e. items that gained many clicks and vice versa. Several alternatives for computing Maturity(k) are known to the inventors. For example, assuming a linear increase of “recommendation power” up to certain upper limit, designated as MAX_clicks, then Maturity(k) can be expressed as: 
         [0000]    
       
         
           
             
               Maturity 
                
               
                 ( 
                 k 
                 ) 
               
             
             = 
             
               
                 Min 
                  
                 
                   { 
                   
                     
                       Number 
                        
                       
                           
                       
                        
                       of 
                        
                       
                           
                       
                        
                       clicks 
                     
                     , 
                     MAX_clicks 
                   
                   } 
                 
               
               MAX_clicks 
             
           
         
       
     
       Where: 
       [0000]    
       
         
           
             Number of Clicks is the number of clicks the items has gained, and 
             MAX_clicks—is a constant reflecting the upper limits of clicks per item that affects its c to be decided based on trial and error. 
           
         
       
     
         [0084]    In this example: if MAX_clicks is =500 then:
   After 0 clicks Maturity(k)=0   After 100 clicks Maturity(k)=0.2   After400 clicks Maturity(k)=0.8   After 500 clicks Maturity(k) =1   
 
       Combining Content-Based and Collaborative Rankings 
       [0089]    Step five of the filtering process of the invention is arrived at with two “vectors” &lt;CF&gt; and &lt;CB&gt;. Each of these vectors contains a ranked list according to a different algorithm (collaborative and the content-based). Each of the vectors is sorted with the highest rank items at the highest index positions. The purpose of this step is to create a combined ranking for the items in the repository for user X. The combined rank for item k, notated as Rank(k), is computed as follows: 
         [0000]      Rank( k )=[(1−Maturity( k ))× CB _Rank( k )]+[Maturity( k )× CF _Rank( k )] 
         [0090]    After the algorithm computes Rank(k) for all the items in the repository, it sorts the items according to Rank(k) and presents the user with the sorted list. The higher an item is on the list, the better rank it has. If the user wants to view only, say, twenty items, the user is presented with the last 20 items from the list. 
       Handling New User 
       [0091]    A new user has no collaborative profile since he has not yet clicked any items. In that case, the system provides the user with the most popular items. For that the system keeps track of the most popular items, i.e., the items that have the most number of clicks (discounted by time). 
       Removal of Decayed Information Items 
       [0092]    The filtering process needs to remove obsolete items from the items repository and archive them. The approach taken in the present invention for dealing with this is to implicitly let the users&#39; community decide when an item becomes obsolete. Since, after a certain period of time, an item is recommended to users mainly based on other users&#39; opinions (i.e. the collaborative filtering component), it is assumed that if an item was not recommended to anyone for a certain period of time it is probably obsolete. Hence, the filtering process maintains for each item in the repository a record of the last time it was recommended to a user. If an item has not been recommended to any user for more than a pre-configured time interval, e.g. 24 hours, it is removed from the repository and preferably transferred to an archive, fro which it can be recovered if specifically called for by a user. 
         [0000]    Capturing Users&#39; feedback 
         [0093]    Items may be presented to the user as headlines with a “more” link next to each headline, (An item&#39;s headline may include the item&#39;s title and potentially some more information such as the source, author and some text from the item&#39;s body.) When a user clicks on a “more” link of a headline, the system presents the user with the entire content of the item. The content page for the item may also include two links: “Interesting” and “not interesting”. If the user clicks on the “not interesting” link, the system will deem the item as not “clicked”; this in fact allows the user to “take back” his click on the “more” link. This explicit relevance feedback is not mandatory, i.e., the user may provide it if he is willing to. 
       Main Function of the Filtering Engine 
       [0094]    The process of the invention is carried out on a filtering engine comprising conventional hardware including input/output devices, memory modules, servers, etc. configured to collect and process the required information according to the steps outlined above. The physical system can be put together in different ways by skilled persons following the description herein. The main features of the information flow in main parts of the filtering engine will now be described. 
       The Collaborative Filter Module 
       [0095]      FIG. 2  schematically illustrates the control flow of the collaborative filter. As described herein above, the purpose of the collaborative filter is to create the vector &lt;CF&gt; from a list of items. In this and the following figures the rectangles represent input to the collaborative filter module from other modules of the filtering engine, the ellipses represent computational and sorting steps carried out within the module, and the arrows show the direction of the data flow. The relative order in which the data moves through the module is indicated by the numerals above the arrows shown in  FIG. 2 , wherein the numerals indicate the following stage of the process:
   1. The collaborative filter is called to create a ranked list of items for user_id   2. Prepare a list of all users who have read items in category_id (where the category_id can be of any level of the categories hierarchy, it can be also the root of categories and thus refer to the whole repository of items)   3. Compute USS between user-id and all those users (from Step 2)   4. Updates the user-similarity table with the computed USS scores   5. Compute CFR score for each item in category-id. This is done by weighting user clicks based on their USS score (similarity to user-id) and the time they clicked on the item 6. Sort items by CFR 7. Return vector &lt;CR&gt;     
       The Rankings Combination Module 
       [0101]    The rankings combination module combines the rankings for the content-based filter and the collaborative filter.  FIG. 3  schematically illustrates the control flow of this module. The relative order in which the data moves through the rankings combination module is indicated by the numerals above the arrows shown in  FIG. 3 , wherein the numerals indicate the following stage of the process:
   1. Start with &lt;CB&gt; and &lt;CR&gt;. Both vectors contain the same items, sorted differently.   2. For each item create a combined score by computing a weighted average between the indexes (locations) of the item in each of the vectors. The weighting between the two indexes is based on the time the item is in the system (read from the item-repository table).   3. Sort the items by the new score and return the result vector &lt;TR&gt;.   
 
       The Update the Collaborative Profile Module 
       [0105]      FIG. 4  schematically illustrates the control flow of the update the collaborative profile module. This module updates the profile of a user after the user was presented with an item (whether he clicked on the item or not). The module input is the user-id, which identifies the user, and the item-id, which identifies the item presented to the user. Also the clicked parameter specifies if the user clicked on the item or not, and the time-stamp parameter specifies the time the item was presented to the user. The relative order in which the data moves through the update the collaborative profile module is indicated by the numerals above the arrows shown in  FIG. 4 , wherein the numerals indicate the following stage of the process:
   1. A request to update the collaborative profile of user-id with item-id, timestamp, and clicked\not-clicked indicator.   2. Update the last-recommended field for the item (the last time the item was recommended to anyone).   3. Update the user&#39;s collaborative profile with a new item-id (including the time-stamp and the clicked indicator).   4. Add another click to the item&#39;s category under the user&#39;s preferred-categories table.     
       Remove Decayed Items Module 
       [0110]      FIG. 5  schematically illustrates the control flow of the update the remove decayed items module. This module determines that an item became obsolete and defines it as Archived. An Archived item will no longer be “pushed” to users, but it can be “pulled” by a user who browses the system. The relative order in which the data moves through the remove decayed items module is indicated by the numerals above the arrows shown in  FIG. 5 , wherein the numerals indicate the following stage of the process:
   1. Invoke the Item Remover every 24 hours (or other pre-configured time interval),   2. For each item in item-repository check if item was not recommended in the last 24 hours. If it was not recommended then move the item from item-repository to the Archive.     
       EXAMPLE 
       [0113]    An example for the entire filtering process of the invention is now presented: 
       Step 1: 
       [0114]    The collaborative filtering module of the system is asked to rank the items in the repository for the user Nancy. The items in repository are presented in the following table: 
         [0000]    
       
         
               
               
               
             
               
               
               
             
           
               
                   
                   
               
               
                   
                   
                 Hours (since added 
               
               
                   
                 Item 
                 to the repository) 
               
               
                   
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 A 
                 3 
               
               
                   
                 B 
                 6 
               
               
                   
                 C 
                 12 
               
               
                   
                 D 
                 4 
               
               
                   
                 E 
                 1 
               
               
                   
                   
               
             
          
         
       
     
       Step 2: 
       [0115]    Assume that the content-based filter (which as said previously is not described herein) returned the following &lt;CB&gt;: 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 CB 
                 Item 
               
               
                   
                   
               
             
             
               
                   
                 1 
                 E 
               
               
                   
                 2 
                 D 
               
               
                   
                 3 
                 A 
               
               
                   
                 4 
                 B 
               
               
                   
                 5 
                 C 
               
               
                   
                   
               
             
          
         
       
     
       Step 3: 
       [0116]    Now the system of the invention calls the collaborative filter to rank the items: Nancy&#39;s Collaborative Profile is: 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 Item 
                 Clicked 
               
               
                   
                   
               
             
             
               
                   
                 U 
                 0 
               
               
                   
                 V 
                 0 
               
               
                   
                 W 
                 1 
               
               
                   
                 X 
                 1 
               
               
                   
                 Y 
                 0 
               
               
                   
                 Z 
                 1 
               
               
                   
                   
               
             
          
         
       
     
         [0117]    Assume that there are 4 other user profiles. The profiles are shown in the following table with the calculated column Time (User, Item). 
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                   
               
               
                 Bob&#39;s collaborative Profile 
               
             
          
           
               
                   
                   
                   
                 Time (Bob, item) = 1/ 
               
               
                 Item 
                 Clicked 
                 Hours (Since Presented) 
                 (e{circumflex over ( )}0.1 * Hours) 
               
               
                   
               
               
                 U 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 V 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 W 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 X 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 Y 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 Z 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 A 
                 1 
                 1 
                 0.9 
               
               
                 B 
                 1 
                 1 
                 0.9 
               
               
                 C 
                 0 
                 1 
                 0.9 
               
               
                 D 
                 1 
                 1 
                 0.9 
               
               
                   
               
             
          
         
       
     
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                   
               
               
                 Ruth&#39;s Collaborative Profile 
               
             
          
           
               
                   
                   
                   
                 Time (Ruth, item) = 1/ 
               
               
                 Item 
                 Clicked 
                 Hours (Since Presented) 
                 (e{circumflex over ( )}0.1 * Hours) 
               
               
                   
               
               
                 U 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 V 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 X 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 Y 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 A 
                 0 
                 0 
                 1 
               
               
                 B 
                 1 
                 0 
                 1 
               
               
                 C 
                 0 
                 0 
                 1 
               
               
                 E 
                 1 
                 0 
                 1 
               
               
                   
               
             
          
         
       
     
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                   
               
               
                 Mike&#39;s Collaborative Profile 
               
             
          
           
               
                   
                   
                   
                 Time (Mike, item) = 1/ 
               
               
                 Item 
                 Clicked 
                 Hours (Since Presented) 
                 (e{circumflex over ( )}0.1 * Hours) 
               
               
                   
               
               
                 V 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 W 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 Y 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 Z 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 A 
                 0 
                 3 
                 0.74 
               
               
                 B 
                 1 
                 3 
                 0.74 
               
               
                 C 
                 0 
                 3 
                 0.74 
               
               
                   
               
             
          
         
       
     
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                   
               
               
                 John&#39;s Collaborative Profile 
               
             
          
           
               
                   
                   
                   
                 Time (John, item) = 1/ 
               
               
                 Item 
                 Clicked 
                 Hours (Since Presented) 
                 (e{circumflex over ( )}0.1 * Hours) 
               
               
                   
               
               
                 U 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 V 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 W 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 X 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 Y 
                 1 
                 Not relevant 
                 Not relevant 
               
               
                 Z 
                 0 
                 Not relevant 
                 Not relevant 
               
               
                 B 
                 1 
                 4 
                 0.67 
               
               
                 C 
                 0 
                 4 
                 0.67 
               
               
                 D 
                 1 
                 4 
                 0.67 
               
               
                   
               
             
          
         
       
     
         [0118]    Note that in the above table, some entries are marked as “Not relevant” since they are new, i.e. they have not yet been presented to user Nancy. 
         [0119]    The system first calculates the User Similarity Score (USS) for Nancy with all the other users (note that this step is conducted off-line for optimization reasons; it is presented here as in-line for clarity) using the formula described hereinabove: 
         [0000]    
       
         
           
             
               USS 
                
               
                 ( 
                 
                   X 
                   , 
                   J 
                 
                 ) 
               
             
             = 
             
               Max 
                
               
                 { 
                 
                   Min_Value 
                   , 
                   
                     
                       Mutual 
                        
                       
                         ( 
                         
                           X 
                           , 
                           J 
                         
                         ) 
                       
                     
                     
                       
                         [ 
                         
                           
                             N 
                              
                             
                               ( 
                               X 
                               ) 
                             
                           
                           + 
                           
                             N 
                              
                             
                               ( 
                               J 
                               ) 
                             
                           
                         
                         ] 
                       
                       × 
                       
                         1 
                         2 
                       
                     
                   
                 
                 } 
               
             
           
         
       
     
         [0120]    The results for this example are: 
         [0000]      USS (Nancy, Bob)=Max (0.05, 3/(6+10)*0.5)=0.375 
         [0000]      USS (Nancy, Ruth)=Max (0.05, 1/(6+8)*0.5)=0.143 
         [0000]      USS (Nancy, Mike)=Max (0.05, 1/(6+7)*0.5)=0.154 
         [0000]      USS (Nancy, John)=Max (0.05, 3/(6+10)*0.5)=0.05 
         [0121]    The system now computes the Collaborative Filtering Rank for each item CFR (k) using the formula described hereinabove: 
         [0000]    
       
         
           
             
               CFR 
                
               
                 ( 
                 k 
                 ) 
               
             
             = 
             
               
                 
                   ∑ 
                   j 
                 
                  
                 
                   [ 
                   
                     
                       USS 
                        
                       
                         ( 
                         
                           X 
                           , 
                           J 
                         
                         ) 
                       
                     
                     × 
                     
                       Time 
                        
                       
                         ( 
                         
                           J 
                           , 
                           k 
                         
                         ) 
                       
                     
                   
                   ] 
                 
               
               
                 Users 
                  
                 
                   ( 
                   k 
                   ) 
                 
               
             
           
         
       
     
         [0122]    The results for this example are: 
         [0000]      CFR (Nancy, Item  A )=[(0.375×0.9)+(0.143×1)+(0.154×0.74)]3/=0.113 
         [0000]      CFR (Nancy, Item  B )= . . . =0.157 
         [0000]      CFR (Nancy, Item  C )= . . . =0.000 
         [0000]      CFR (Nanry, Item  D )=[(0.375×0.9)+(0.05×0.67)]/2=0.186 
         [0000]      CFR (Nancy, Item  E )= . . . =0.143 
         [0123]    The resulting &lt;CF&gt; vector is: 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 CF 
                 Item 
               
               
                   
                   
               
             
             
               
                   
                 1 
                 D 
               
               
                   
                 2 
                 B 
               
               
                   
                 3 
                 E 
               
               
                   
                 4 
                 A 
               
               
                   
                 5 
                 C 
               
               
                   
                   
               
             
          
         
       
     
       Step 4: 
       [0124]    The Maturity factor for all the items is now computed assuming that MAX_clicks is set to 10: 
         [0000]    
       
         
               
               
               
             
               
               
               
             
           
               
                   
               
               
                   Item 
                  Number ofclicks gained 
                 
                   
                     
                       
                         Maturity 
                         = 
                         
                           
                             Min 
                              
                             
                               { 
                               
                                 
                                   Number 
                                    
                                   
                                       
                                   
                                    
                                   of 
                                    
                                   
                                       
                                   
                                    
                                   clicks 
                                 
                                 , 
                                 MAX_clicks 
                               
                               } 
                             
                           
                           MAX_clicks 
                         
                       
                     
                   
                 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 A 
                 1 
                 0.1 
               
               
                 B 
                 3 
                 0.3 
               
               
                 C 
                 0 
                 0. 
               
               
                 D 
                 2 
                 0.2 
               
               
                 E 
                 1 
                 0.1 
               
               
                   
               
             
          
         
       
     
       Step 5: 
       [0125]    Finally, &lt;CB&gt; is combined with &lt;CF&gt; to get the combined (total) rank &lt;TR&gt;. For simplicity a simple linear merge of the two lists is shown. A more correct and effective method of merging the two lists can be defined for use in practice: 
         [0000]    
       
         
               
               
               
               
               
             
           
               
                   
                   
               
               
                   
                 CF 
                 Item 
                 CB 
                 Item 
               
               
                   
                   
               
             
             
               
                   
                 1 
                 D 
                 1 
                 E 
               
               
                   
                 2 
                 B 
                 2 
                 D 
               
               
                   
                 3 
                 E 
                 3 
                 A 
               
               
                   
                 4 
                 A 
                 4 
                 B 
               
               
                   
                 5 
                 C 
                 5 
                 C 
               
               
                   
                   
               
             
          
         
       
     
         [0126]    Applying the formula: 
         [0000]      Rank( k )=[(1−Maturity( k ))× CB _Rank( k )]+[Maturity(k)× CF _Rank( k )] 
         [0000]      yields: 
         [0000]      TR( A )=[(1−0.1)×3]+[0.1 ×4]=3.1 
         [0000]      TR( B )= . . . =3.4 
         [0000]      TR( C )= . . . =5.000 
         [0000]      TR( D )= . . . =1.8 
         [0000]      TR( E )=[(1−0.1)×1]+[0.1×3]=1.2 
         [0127]    Expressed in the form of a table, the filtering system of the invention has produced the following time-space collaborative ranking of the items in the repository for Nancy: 
         [0000]    
       
         
               
               
               
             
               
               
               
             
           
               
                   
                   
               
               
                   
                 TR 
                 Item 
               
               
                   
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 5 
                 C 
               
               
                   
                 3.4 
                 B 
               
               
                   
                 3.1 
                 A 
               
               
                   
                 1.8 
                 D 
               
               
                   
                 1.2 
                 E 
               
               
                   
                   
               
             
          
         
       
     
         [0128]    Although embodiments of the invention have been described by way of illustration, it will be understood that the invention may be carried out with many variations, modifications, and adaptations, without exceeding the scope of the claims.