Abstract:
Crowdsourcing is described, for example, where solutions to tasks such as designing a logo, writing a piece of code or answering a question are solicited by making open calls to large scale communities. In an example, a crowdsourcing node models a plurality of contests as all-pay auctions, each contest having a task and a reward. In examples, the crowdsourcing node is arranged to set rewards for the contests so that the optimal results are received for each contest owner, those owners having provided a budget and using a utility function for each of the contests. In examples, the crowdsourcing node is arranged to recommend contests to potential participants so that those participants can more easily decide which tasks to take on next.

Description:
BACKGROUND 
       [0001]    Crowdsourcing systems are currently used to implement web services where solutions to tasks are solicited via open calls to large-scale communities. Crowdsourcing systems typically provide information describing tasks and, for each task, state a reward and a time period. During the time period users compete to provide the best submission. At the conclusion of the period, a subset of submissions are selected and the corresponding users are granted the reward. Examples of tasks found on existing crowdsourcing web sites are: the graphical design of logos, the creation of a marketing plan, the identification and labeling of an image, and the answering of an individual&#39;s question. 
         [0002]    The rewards offered may be monetary or non-monetary; non-monetary rewards can take the form of reputation points in community question and answer sites and confer a measure of social status within these communities. 
         [0003]    From the point of view of the providers of the tasks, it is difficult to guarantee the appropriate quality of submissions and to ensure that sufficient numbers of users make submissions for a given task. 
         [0004]    From the point of view of the users it is difficult to decide which tasks to attempt in order to gain the highest total rewards in a given time. 
         [0005]    The embodiments described herein are not limited to implementations which solve any or all of the disadvantages of known crowdsourcing systems. 
       SUMMARY 
       [0006]    The following presents a simplified summary of the disclosure in order to provide a basic understanding to the reader. This summary is not an extensive overview of the disclosure and it does not identify key/critical elements of the invention or delineate the scope of the invention. Its sole purpose is to present some concepts disclosed herein in a simplified form as a prelude to the more detailed description that is presented later. 
         [0007]    Crowdsourcing is described, for example, where solutions to tasks such as designing a logo, writing a piece of code or answering a question are solicited by making open calls to large scale communities. In an example, a crowdsourcing node models a plurality of contests as all-pay auctions, each contest having a task and a reward. In examples, the crowdsourcing node is arranged to set rewards for the contests so that the optimal results are received for each contest owner, those owners having provided a budget and using a utility function for each of the contests. In examples, the crowdsourcing node is arranged to recommend contests to potential participants so that those participants can more easily decide which tasks to take on next. 
         [0008]    Many of the attendant features will be more readily appreciated as the same becomes better understood by reference to the following detailed description considered in connection with the accompanying drawings. 
     
    
     
       DESCRIPTION OF THE DRAWINGS 
         [0009]    The present description will be better understood from the following detailed description read in light of the accompanying drawings, wherein: 
           [0010]      FIG. 1  is a schematic diagram of a crowdsourcing system; 
           [0011]      FIG. 2  is an example cost function; 
           [0012]      FIG. 3  is an example utility function; 
           [0013]      FIG. 4  is a flow diagram of a method at a crowdsourcing system to set relative rewards for contests; 
           [0014]      FIG. 5  is a flow diagram of another method at a crowdsourcing system to set relative rewards for contests; 
           [0015]      FIG. 6  is a schematic diagram of another crowdsourcing system; 
           [0016]      FIG. 7  is an example weighted mapping between user skill levels and types of contest; 
           [0017]      FIG. 8  is a flow diagram of a method at a crowdsourcing system of selecting contests for recommending to a user; 
           [0018]      FIG. 9  illustrates an exemplary computing-based device in which embodiments of a crowdsourcing system may be implemented. 
       
    
    
       [0019]    Like reference numerals are used to designate like parts in the accompanying drawings. 
       DETAILED DESCRIPTION 
       [0020]    The detailed description provided below in connection with the appended drawings is intended as a description of the present examples and is not intended to represent the only forms in which the present example may be constructed or utilized. The description sets forth the functions of the example and the sequence of steps for constructing and operating the example. However, the same or equivalent functions and sequences may be accomplished by different examples. 
         [0021]    Although the present examples are described and illustrated herein as being implemented in a crowdsourcing system in which many task providers obtain solutions to tasks via the crowdsourcing system, the system described is provided as an example and not a limitation. As those skilled in the art will appreciate, the present examples are suitable for application in a variety of different types of crowdsourcing systems including those where all the tasks are offered by the same entity. 
         [0022]      FIG. 1  is a schematic diagram of a crowdsourcing system comprising a crowdsourcing node  100  and a reward engine  102 . The crowdsourcing node  100  is provided using a web server or other computing-based device which is connected to a communications network such as the Internet or other communications network. This enables the crowdsourcing node to be in communication with a large scale population of users  104 . The crowdsourcing node  100  is in communication with a reward engine  102  which may be integral with the crowdsourcing node  100  although that is not essential. The reward engine is arranged to set relative rewards for all contests (i.e. tasks) offered by the crowdsourcing node. It may also be arranged to recommend a reward to an entity which posts a contest at the crowdsourcing node. A system operator  103  is also in communication with the crowdsourcing node and is a provider of the crowdsourcing service. However, it is not essential for a system operator to be present. The crowdsourcing node may be operated by the contest owners in a collaborative manner. 
         [0023]    The crowdsourcing node stores or has access to details of a plurality of contests  101  each having an associated reward. Each contest comprises a task and a time period for completing the task. Each contest has a contest owner and the contest owners may be different for each task but this is not essential. The contest owners are any entities such as enterprises or individuals who specify requirements for a task including a budget for any rewards offered. For each contest, a contest budget  105  is provided as input to the crowdsourcing node  100 . Also, for each contest, a contest owner utility function  106  is provided as input to the crowdsourcing node. 
         [0024]    An example of a contest owner budget is the cost function shown in  FIG. 2 . Cost is plotted against reward so that, if the cost is equal to reward then a linearly increasing cost function results. However, in the example of  FIG. 2  the cost function  200  is convex with the cost increasing with reward but never reaching a particular reward value R  201  stated by the contest owner as the budget. In this way the cost function captures the degree of satisfaction of the contest owner. If the cost is much less than the stated reward the contest owner is satisfied. However, if the cost is almost the same as the stated reward the contest owner is less satisfied. The example in  FIG. 2  is just one form of suitable cost function. Other forms of cost function may be used. The cost functions may be input to the crowdsourcing node  100  by other entities and/or they may be pre-configured at the crowdsourcing node. For example, a plurality of different types of cost function may be pre-configured and a contest owner may simply pick one of these or a default cost function may be selected. 
         [0025]    An example of a contest owner utility function  300  is given in  FIG. 3 . In this example the utility of a particular contest to the contest owner increases with the average number of participants in that contest. In this example, the utility function is concave although other forms of function may be used. In some embodiments the contest owner utility function is input to the crowdsourcing system by another entity. For example, the utility function may be determined using an offline process and provided as input by a contest owner. In other embodiments a plurality of utility functions are preconfigured at the crowdsourcing node  100  for a plurality of different contest types. The reward engine  102  is arranged to use information about contest types to select appropriate ones of the pre-configured utility functions for use in setting relative rewards for the contests. It is also possible for contest owners to select from the pre-configured utility functions. In high level terms the utility functions can be thought of as a mechanism by which a contest owner is able to specify “I require on average x participants in my contest”. The mean number of participants (i.e. players) in a contest is referred to herein using the symbol “λ”. This parameter may be observed by the crowdsourcing node  100  which is arranged to monitor the number of participants in each contest  101  over time. The crowdsourcing node  100  may also be arranged to estimate or monitor the total number of potential participants  104 . For example, this may be achieved by providing a registration process whereby all potential participants provide user details to the crowdsourcing node  100 . The total number of potential participants N may then be estimated as the portion of the registered users who are currently active. Any other suitable way of estimating N may be used. 
         [0026]    As mentioned above, the reward engine is arranged to set relative rewards for all contests (i.e. tasks) offered by the crowdsourcing node. It may also be arranged to recommend a reward to a contest owner. A system operator  103  is also in communication with the crowdsourcing node and is a provider of the crowdsourcing service. Suppose that the relative rewards are set by the system operator in order to provide the optimal contest outcomes for each contest owner. This may be referred to as a “system welfare problem”. Another possibility is that the contest owners&#39; collaborate with one another and agree to set relative rewards in a manner to give jointly optimal contest outcomes. In this case the reward engine  102  is arranged to set relative rewards for the contests for example, as now described with reference to  FIG. 4 . This method may also be used to recommend rewards to contest owners by determining the relative rewards and recommending those to the contest owners. 
         [0027]    A total number of users (also referred to as participants or players in the contests) is observed  400  by the crowdsourcing node and provided to the reward engine. The reward engine has information about a plurality of contests and is arranged to access  400  a utility function as mentioned above for each contest. The reward engine also receives  402  a contest budget for each of the contests. 
         [0028]    The reward engine is arranged to optimize  403  an objective which is related to the aggregated utility over all contests minus the aggregated cost over all contests. The optimization is carried out using any suitable optimizer provided at the reward engine. For example, the optimizer may use gradient descent or any other suitable optimization method. The result  404  gives a relative reward for each contest and these relative rewards may be scaled as required by the system operator. 
         [0029]    For example, suppose that each contest j is associated with a utility U j (λ j ) for the mean number of participants in this contest λ j ≧0 Suppose also that each contest j is associated with a cost C j ({right arrow over (R)}) for a vector of given non-negative rewards {right arrow over (R)}=(R j , . . . , R K ). Assume {right arrow over (R)} takes values from a given set           that is a subset of [0,∞) K . 
         [0030]    A system welfare problem is defined as follows: 
         [0000]    
       
         
           
             
               
                 SYSTEM 
               
               
                 
                     
                 
               
             
             
               
                 maximise 
               
               
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     K 
                   
                    
                   
                     
                       v 
                       k 
                     
                     [ 
                     
                       
                         
                           U 
                           k 
                         
                         ( 
                         
                           
                             λ 
                             k 
                           
                           ( 
                           
                             R 
                             -&gt; 
                           
                           ) 
                         
                         ) 
                       
                       - 
                       
                         
                           C 
                           k 
                         
                         ( 
                         
                           R 
                           -&gt; 
                         
                         ) 
                       
                     
                     ] 
                   
                 
               
             
             
               
                 over 
               
               
                 
                   R 
                   ∈ 
                    
                 
               
             
             
               
                 
                   subject 
                    
                   
                       
                   
                    
                   to 
                 
               
               
                 
                   
                     
                       ∑ 
                       
                         k 
                         = 
                         1 
                       
                       K 
                     
                      
                     
                       
                         v 
                         k 
                       
                        
                       
                         λ 
                         k 
                       
                     
                   
                   = 
                   λ 
                 
               
             
           
         
       
     
         [0031]    In some embodiments the rewards given are non-monetary and in these cases the cost budgets are zero. For example, if the rewards are reputation points then the cost budget is zero. Examples of these embodiments are now discussed with reference to  FIG. 5 . 
         [0032]    The crowdsourcing node  100  is arranged to observe and/or estimate 500 the total number N of potential users of the crowdsourcing service. As for the method of  FIG. 4  this may be achieved by requiring users to register with the crowdsourcing node before participating in a contest or it may be achieved by monitoring all current participants. Any other method of estimating or observing N may be used. The reward engine  102  is arranged to access  501  a utility function for each contest as described above with reference to  FIG. 4 . The reward engine proceeds to find a parameter μ (referred to herein as the shadow price) by solving an equation relating p to the average number of players per contest λ. The average number of players per contest can be thought of as the demand for contests. 
         [0033]    The reward engine makes an assessment  503  as to whether the total number of participants N is greater than a threshold. If so then a large scale limit is assumed to apply and the relative rewards for each contest are found  505  from a specified relationship between a reward and the shadow demand which is independent of the total number of participants N. Otherwise, if the large scale limit is taken not to apply, then the relative rewards are found  504  from a specified relationship between a reward and the shadow demand which depends on the total number of participants N. 
         [0034]    Examples of the specified relationships between reward and shadow demand are now given. In these examples, the utility functions for each contest are increasing, concave functions of the average number of participants per contest. However, this is not essential. Other forms of utility function may be used and corresponding changes to the specified relationships made. 
         [0035]    Consider the system C k (•)≡0 for each contest class k and rewards taking values on          =[0,∞) K . Suppose that for each contest class k, U k (λ k ) is an increasing, strictly concave function of λ k ≧0. Let U′ k  denote the marginal utility and U′ k   −1  its inverse. 
         [0036]    In this case it is found that, under player-specific skills (player and contest specific skills assumptions are explained in more detail later), optimal rewards are unique up to a multiplicative constant. Moreover for any c&gt;0, 
         [0000]    
       
         
           
             
               
                 R 
                 j 
               
               = 
               
                 
                   c 
                   ( 
                   
                     1 
                     - 
                     
                       
                         
                           U 
                           j 
                           
                             ′ 
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           μ 
                           ) 
                         
                       
                       N 
                     
                   
                   ) 
                 
                 
                   - 
                   
                     ( 
                     
                       N 
                       - 
                       1 
                     
                     ) 
                   
                 
               
             
             , 
             
               j 
               = 
               1 
             
             , 
             … 
              
             
                 
             
             , 
             K 
             , 
           
         
       
     
         [0000]    where μ is a unique solution of 
         [0000]    
       
         
           
             
               
                 ∑ 
                 
                   k 
                   = 
                   1 
                 
                 K 
               
                
               
                 
                   v 
                   k 
                 
                  
                 
                   
                     U 
                     k 
                     
                       ′ 
                       - 
                       1 
                     
                   
                    
                   
                     ( 
                     μ 
                     ) 
                   
                 
               
             
             = 
             λ 
           
         
       
     
         [0037]    In the large system limit, optimal rewards are unique up to a multiplicative constant. Moreover for any c&gt;0 , 
         [0000]      R j =ce U′     j       −1     (μ) ,j=1, . . . , K, 
         [0000]    where μ is a unique solution of 
         [0000]    
       
         
           
             
               
                 ∑ 
                 
                   k 
                   = 
                   1 
                 
                 K 
               
                
               
                 
                   v 
                   k 
                 
                  
                 
                   
                     U 
                     k 
                     
                       ′ 
                       - 
                       1 
                     
                   
                    
                   
                     ( 
                     μ 
                     ) 
                   
                 
               
             
             = 
             λ 
           
         
       
     
         [0038]    In other embodiments the rewards are monetary and so the cost budgets are not zero. In these cases the reward engine is arranged to set appropriate relative rewards for the contests using a two stage process where the large scale limit applies (i.e. the total number of participants N is above a threshold). The first step comprises optimizing a utility function over average number of participants per contest to find an optimal average number of participants for each contest. The second step comprising finding the relative rewards for the contests given the observed total number of participants and the utility functions for each contest. A detailed example of this is now given. 
         [0039]    In the large-system limit under the assumption of contest-specific skills, the revenue for a contest of class j is given by 
         [0000]      Π j (λ j )= R   j   m   j (1−(1+λ j ) e   −λ     j   ) 
         [0000]    where R j  is the offered reward, m j  is the maximum skill and λ j  is the expected number of participants for contest j in equilibrium. The maximum skill is explained later. This revenue corresponds to the total amount of effort put forth by the players in the contest. It corresponds to a revenue of m j  when two or more players are present and 0 otherwise. This revenue is not relevant in all circumstances; in many contests, only the effort put forth by the strongest player is important. Nonetheless, in contests where the player&#39;s effort may be usefully aggregated, this quantity warrants inspection. 
         [0040]    Consider the SYSTEM problem with 
         [0000]        U   j (λ j )= V   j (Π j (λ j )), 
         [0000]    Where V j (Π j ) is the utility from contest j where the revenue in that contest is Π j . Suppose that the cost is D j (R j ) for reward R j  if the contest is attended by at least one player; this corresponds to C j ({right arrow over (R)})=(1−e −λ     j     ({right arrow over (R)}) )D j (R j ), 
         [0041]    The reward engine is arranged to use a two step procedure as follows. For some r&gt;0, R j =re λj , whenever λ J &gt;0. The first step amounts to solving, for fixed r&gt;0, and j=1, . . . , K, 
         [0000]      maximise V j (re −λ     j   m j (1−(1+λ j )e −λ     j   ))−(1−e −λ     j   )D j (re −λ     j   ) 
         [0000]      over λ j ≧0. 
         [0042]    This yields a solution to λ j (r). The second step amounts to finding r≧0 such that 
         [0000]    
       
         
           
             
               
                 ∑ 
                 
                   k 
                   = 
                   1 
                 
                 K 
               
                
               
                 
                   v 
                   k 
                 
                  
                 
                   
                     λ 
                     k 
                   
                    
                   
                     ( 
                     r 
                     ) 
                   
                 
               
             
             = 
             
               λ 
               . 
             
           
         
       
     
         [0043]    In embodiments described herein the crowdsourcing node  100  comprises or has access to a model of the contests  101 . For example, a data structure is stored at the crowdsourcing node  100  which holds a model of the contests as all-pay auctions. In addition the data structure may hold information describing belief about one or more probability distributions representing skills of players. In some embodiments the skills may be player-specific in that each player is modeled with a skill that applied across all contests. In other embodiments contest-specific skills are modeled whereby each player has different skills for different types of contest. 
         [0044]    For example, the data structure may hold a model which represents each contest as a one-shot game in which players select a contest, exert effort (at a cost that depends on their skill), and in each contest the player with the best effort wins a prize. Specifically, consider a game in which N players chose among J contests. Let R j  denote the reward offered in contest jε{1, . . . J}. Associated with each player i is a vector of skills {right arrow over (v)} 1 =(v i1 , . . . , v iJ ), where v iJ  represents a player i&#39;s skill at a contest j. Suppose that the skill vector for each player is drawn from a continuous joint probability distribution over [0,m] j , that skill vectors for different players are drawn independently from each other, and that the distribution is known to all players but the skill vector {right arrow over (v)} i  is only known to player i. The parameter m represents a maximum possible skill, for example, corresponding to an upper limit on the amount of effort a player can obtain from a unit cost. 
         [0045]    The game consists of two stages. In the first stage each player i selects a contest j and a bid b ij . In the second stage, in each contest j, the prize is awarded to the player with the highest bid among those who selected the contest. Since bids represent effort (which cannot be unspent), all bids are collected. The payoff to player i is v ij R j −b ij  if he submitted the highest bid and b ij  otherwise. In the event of a tie the winner is selected uniform at random among the highest bidders. 
         [0046]    The contests may be modeled as all-pay auctions—these are auctions in which the highest bidder receives the object, but all bidders pay their bid to the auctioneer. To see the connection between contests and all pay auctions suppose the skill of player i at contest j is modeled by a unit cost of effort c ij . If he exerts effort b ij  and wins, his payoff is R j −c ij b ij ; if he loses he still pays the cost c ij b ij . Scaling his payoffs by dividing by c ij , the game above is reached when 
         [0000]    
       
         
           
             
               v 
               ij 
             
             = 
             
               
                 1 
                 
                   c 
                   ij 
                 
               
               . 
             
           
         
       
     
         [0000]    Thus, a player&#39;s skill v ij . may be interpreted as the amount of effort he is able to exert per unit cost. 
         [0047]    In some embodiments, while a given player does not know the skills of the other players, he is aware of the underlying distribution. Additionally, all other information is public—all players are aware of the number of players N the number of contests J, and the reward offered in each contest. In these cases the crowdsourcing model holds a model of the contests which is a model of incomplete information. 
         [0048]    For example, a mixed strategy for a player i with skills {right arrow over (v)} i  consists of a probability distribution {right arrow over (π)}=(π i1 , . . . , π ij ) over the contests together with a bid b ij  for each contest j. Player i&#39;s payoff is the expected payoff in the all-pay auction, with the expectation taken over his own mixed strategy and i&#39;s beliefs about other players&#39; types and strategies. His mixed strategy is a best response if is yields him at least as high a payoff as any other strategy. {right arrow over (π)} i  is independent of the player i and π j ({right arrow over (v)}) denotes the probability that a player with skill {right arrow over (v)} joins contest j. 
         [0049]    In some embodiments the crowdsourcing node  100  comprises a contest recommendation engine  600  as now described with reference to  FIG. 6 . As in  FIG. 1  a community of potential participants  104  is in communication with the crowdsourcing node using a communications network of any suitable type. The crowdsourcing node is arranged to receive input comprising user skill information  601  and to provide contest recommendations  602  as output using the contest recommendation engine. For example, a potential participant in the community  104  may receive contest recommendations about which of the available contests  101  to participate in. The crowdsourcing node comprises a model of the contests  101  as described above and this model may be stored at a memory at the node. The contest recommendation engine  600  may also be used to assign contests to potential participants in a similar manner. For example, rather than recommending a contest which the potential participant then decides whether to take up, the engine  600  simply assigns one or more contests to that participant. 
         [0050]    As mentioned above a user&#39;s skill can be thought of as the amount of effort or good that a user can produce by unit time. This may be observed or measured in some way, such as by observing the number of successful contest outcomes attained by a user in a given time period. For example, software may be provided at a computer used by the user to monitor time spent on tasks for particular contests and to provide this information to the crowdsourcing node. Alternatively, the information may be provided by the user him or herself as part of a registration process at the crowdsourcing node or in any other manner. For example, as part of the registration process the user may provide details of education and training history as well as relevant past experience. Rules and thresholds at the crowdsourcing node may be used to analyze this information and to classify the potential participants in the community  104  into a plurality of pre-defined skill levels. 
         [0051]    In some embodiments, the crowdsourcing node is arranged to deal with situations in which skill history information is available for the potential participants in the community  104 . In these cases, a skill level is known for each contest participant. In other embodiments, the crowdsourcing node is arranged to deal with situations where skill history information is unavailable. 
         [0052]    Embodiments in which skill history information for individual participants is unavailable are now described. The crowdsourcing node is arranged to observe or monitor a number N which is the total number of potential contest participants in the community  104 . This number may be monitored as described above or may be estimated by the crowdsourcing node  100 . The crowdsourcing node also has access to a reward value for each of the contests  101  which may be computed by the system operator  103  (for example, as described above with reference to  FIG. 5 ) in any suitable manner or may be pre-configured. Contests which offer the same or similar reward in magnitude are considered as a class of contests. The crowdsourcing node also receives information about a distribution F(v) across skills in the user population. For example, this information may be that 10% of the community  104  have skills less than 0.2. This information may be monitored or observed by the crowdsourcing node itself or may be provided by an external entity. 
         [0053]    In some examples, the model of the contests at the crowdsourcing node  100  is arranged to represent the skills of the contest participants (players) in such a way that each player&#39;s skill is independent of the particular contests. This is appropriate in applications where the contests comprise tasks that are closely related and/or require a similar kind of talent. This is also appropriate in applications where all players require a similar amount of time to put forth effort but different players face different hourly opportunity costs. For each player i the skill vector {right arrow over (v)} is equal to (v, v, . . . , v) where v is drawn from the distribution F(v) independently of the skill of other players. 
         [0054]    For example, there are K classes of contests with rewards R 1 &gt;R 2 &gt; . . . &gt;R K . Using the notation {right arrow over (R)}=(R 1 , . . . , R K ) and for any subset A ⊂ {1, . . . , K}, let 
         [0000]    
       
         
           
             
               
                 H 
                 A 
               
               ( 
               
                 R 
                 -&gt; 
               
               ) 
             
             = 
             
               
                 ( 
                 
                   
                     ∑ 
                     
                       k 
                       ∈ 
                       A 
                     
                   
                    
                   
                     
                       
                         J 
                         k 
                       
                       
                         J 
                         A 
                       
                     
                      
                     
                       R 
                       k 
                       
                         1 
                         
                           N 
                           - 
                           1 
                         
                       
                     
                   
                 
                 ) 
               
               
                 - 
                 1 
               
             
           
         
       
       
         
           
             
               J 
               A 
             
             = 
             
               
                 ∑ 
                 
                   k 
                   ∈ 
                   A 
                 
               
                
               
                 
                   J 
                   k 
                 
                 . 
               
             
           
         
       
     
         [0000]    Additionally, for A={1, . . . , l} write A=[1,l]. 
         [0055]    It is found that a contest is selected by a player with a strictly positive probability if the reward offered by this contest is one of the {right arrow over (K)} highest rewards, where 
         [0000]    
       
         
           
             
               K 
               
                 -&gt; 
                 ~ 
               
             
             = 
             
               max 
                
               
                 
                   { 
                   
                     i 
                     : 
                     
                       
                         R 
                         i 
                         
                           1 
                           
                             N 
                             - 
                             1 
                           
                         
                       
                       &gt; 
                       
                         
                           ( 
                           
                             1 
                             - 
                             
                               1 
                               
                                 J 
                                  
                                 
                                   [ 
                                   
                                     1 
                                     , 
                                     i 
                                   
                                   ] 
                                 
                               
                             
                           
                           ) 
                         
                          
                         
                           
                             H 
                             
                               [ 
                               
                                 1 
                                 , 
                                 i 
                               
                               ] 
                             
                           
                           ( 
                           
                             R 
                             -&gt; 
                           
                           ) 
                         
                       
                     
                   
                   } 
                 
                 . 
               
             
           
         
       
     
         [0056]    Also a player selects a particular a particular contest of class j with probability p j  given by 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                     j 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               1 
                               - 
                               
                                 
                                   ( 
                                   
                                     1 
                                     - 
                                     
                                       1 
                                       
                                         J 
                                         
                                           [ 
                                           
                                             1 
                                             , 
                                             
                                               K 
                                               ~ 
                                             
                                           
                                           ] 
                                         
                                       
                                     
                                   
                                   ) 
                                 
                                  
                                 
                                   
                                     
                                       H 
                                       
                                         [ 
                                         
                                           1 
                                           , 
                                           
                                             
                                               K 
                                               ~ 
                                             
                                              
                                             1 
                                           
                                         
                                         ] 
                                       
                                     
                                     ( 
                                     
                                       R 
                                       -&gt; 
                                     
                                     ) 
                                   
                                   
                                     R 
                                     j 
                                     
                                       1 
                                       
                                         N 
                                         - 
                                         1 
                                       
                                     
                                   
                                 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               j 
                             
                             ≤ 
                             
                               K 
                               ~ 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           otherwise 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0057]    The contest recommendation engine  600  stores a data structure holding the relationship specified in equation 1 above. This relationship gives the probability that a player will select a particular contest of a given class in terms of the rewards for each contest class and the total number of participants N. The contest recommendation engine  600  uses the relationship in the data structure to rank the contests  101  and create a ranked list of contests to provide as output  602 . 
         [0058]    In other embodiments, skill history information is available so that a skill level is known for each potential participant in the community  104 . In these cases the crowdsourcing node may again be arranged to model the population of player skills such that each player is endowed with a skill which is the same across all contests. However, each player may have his or her own individual skill level. This is referred to herein as “player-specific skills with levels”. In these embodiments the crowdsourcing node receives skill level intervals or uses configured data about this. For example, this input specifies the number of skill levels required and the intervals between the levels. The system operator  103  is able to adjust the number of skill levels and the skill level intervals as required for different applications, numbers and classes of contests  101 . 
         [0059]    The contest recommendation engine  600  has a data structure storing a function for partitioning the population of users into the skill levels. An example of this function is given in equation 2 below. It also has another data structure holding a relationship specifying the probability that a player of a particular skill selects a particular contest of a given class. An example of this relationship is given in equation 3 below. This probability relationship is used by the contest recommendation engine  600  to rank contests in a skill specific way and so to create a list of recommended contests  602  for a particular user. For example, given a user with a particular skill, the contest recommendation engine maps that user to a given skill level. From that skill level the contest recommendation engine is then able to obtain a distribution across contest classes, for example, using equation 3 below. 
         [0060]    Players are partitioned over {tilde over (K)} skill levels such that a skill level l corresponds to an interval of skill values [v l+1 ,v l ), where 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       F 
                        
                       
                         ( 
                         
                           v 
                           l 
                         
                         ) 
                       
                     
                     = 
                     
                       1 
                       - 
                       
                         
                           J 
                           
                             [ 
                             
                               1 
                               , 
                               l 
                             
                             ] 
                           
                         
                         ( 
                         
                           1 
                           - 
                           
                             
                               R 
                               l 
                               
                                 1 
                                 
                                   N 
                                   - 
                                   1 
                                 
                               
                             
                             
                               
                                 H 
                                 
                                   [ 
                                   
                                     1 
                                     , 
                                     l 
                                   
                                   ] 
                                 
                               
                               ( 
                               
                                 R 
                                 -&gt; 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    For l=1, . . . , {tilde over (K)}, and v l =0 for l={tilde over (K)}+1, . . . , K. 
         [0061]    A player of skill v selects a particular contest of class j with a probability π j (v) given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       π 
                       j 
                     
                      
                     
                       ( 
                       v 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 R 
                                 j 
                                 
                                   - 
                                   
                                     1 
                                     
                                       N 
                                       - 
                                       1 
                                     
                                   
                                 
                               
                               
                                 
                                   ∑ 
                                   
                                     k 
                                     = 
                                     1 
                                   
                                   l 
                                 
                                  
                                 
                                   
                                     J 
                                     k 
                                   
                                    
                                   
                                     R 
                                     k 
                                     
                                       - 
                                       
                                         1 
                                         
                                           N 
                                           - 
                                           1 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               
                                 for 
                                  
                                 
                                     
                                 
                                  
                                 j 
                               
                               = 
                               1 
                             
                             , 
                             … 
                              
                             
                                 
                             
                             , 
                             l 
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           
                             
                               
                                 for 
                                  
                                 
                                     
                                 
                                  
                                 j 
                               
                               = 
                               
                                 l 
                                 + 
                                 1 
                               
                             
                             , 
                             … 
                              
                             
                                 
                             
                             , 
                             K 
                             , 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    For vε[v l+1 ,v l ). Thus a player of skill level l selects a contest that offers one of l highest rewards. 
         [0062]    Equation 1 says that in equilibrium players are partitioned over a finite set of skill levels. Equation 2 tells us that a player of skill level l randomly selects a contest among those that offer one of the highest rewards. Note that a small value of l denotes a higher level of skill. The players of skill level select the l-th highest reward with the largest probability and those that offer larger reward are selected with smaller probability. A player of skill level l selects a contest that offers the j-th highest reward where j=1, . . . , l, with probability inversely proportional to R j   1/N−1 ). 
         [0063]    An example in which there are 5 contest classes and four skill levels is shown in  FIG. 7 . The contest recommendation engine partitions the population of users into four skill levels as illustrated (with the maximum skill being m). The distribution across contest classes known from equation 3 is used to determine weighted links between the skill levels and contest classes. These weighted links are represented by arrows in  FIG. 7  with the thickness of the arrows indicating the likelihood that a player joins that particular contest class. In the example in  FIG. 7  contest  1  has the highest reward and players with skills in level  1  are in the highest segment of [0, m]. 
         [0064]    With reference to  FIG. 8  the crowdsourcing node  100  receives user skill information  800  for a particular user and selects an appropriate skill level for that user  801  using the contest recommendation engine  600 . For the selected skill level the contest recommendation engine  600  is arranged to access  802  a weighted mapping to a set of contest classes and to use  803  that mapping to select contests for recommending. 
         [0065]    In the large system limit i.e. where there are many contests offering the same rewards and the total number of participants N is large, then the contest recommendation engine is able to use a simpler process. The contest recommendation engine  600  may incorporate rules, thresholds or other criteria for assessing whether the large system limit applies. In this case, the arrows in  FIG. 7  do not need to be weighted. Rather the contest recommendation engine simply selects those contest classes that offer the l highest rewards where l is the skill level of the player concerned. The contest recommendation engine then recommends all the selected contest classes or selects a subset of those to recommend to the user. The sub set may be selected in any suitable manner for example, by making a random selection, on the basis of past history for that user, on the basis of information about the contests or in any other way. 
         [0066]    In the embodiments discussed above, the model of the contests at the crowdsourcing node  100  is arranged to represent the skills of the contest participants (players) in such a way that each player&#39;s skill is independent of the particular contests. However, it is also possible for the model to represent skills of the players in a contest-specific manner. In this case, a given player has different skills for different classes of contest. In this case, where the large system limit applies then the contest recommendation engine  600  simply uses the same methods as described above to recommend contests to users. 
         [0067]    Technical report MSR-TR-2009-9 “Crowdsourcing and All-Pay Auctions” February 2009 is incorporated herein by reference in its entirety. 
         [0068]      FIG. 9  illustrates various components of an exemplary computing-based device  900  which may be implemented as any form of a computing and/or electronic device, and in which embodiments of a crowdsourcing system may be implemented. 
         [0069]    The computing-based device  900  comprises one or more inputs  906  which are of any suitable type for receiving media content, Internet Protocol (IP) input, files, user registration details, contest owner budgets, contest owner utility functions, system operator instructions, user skill information, user population information and other input. The device also comprises communication interface  907  to enable the device to communicate with other entities over any suitable type of communications network. 
         [0070]    Computing-based device  900  also comprises one or more processors  901  which may be microprocessors, controllers or any other suitable type of processors for processing computing executable instructions to control the operation of the device in order to provide a crowdsourcing system. Platform software comprising an operating system  904  or any other suitable platform software may be provided at the computing-based device to enable application software  903  to be executed on the device. 
         [0071]    The computer executable instructions may be provided using any computer-readable media, such as memory  902 . The memory is of any suitable type such as random access memory (RAM), a disk storage device of any type such as a magnetic or optical storage device, a hard disk drive, or a CD, DVD or other disc drive. Flash memory, EPROM or EEPROM may also be used. 
         [0072]    An output including a display interface  905  is also provided such as an audio and/or video output to a display system integral with or in communication with the computing-based device. The display system may provide a graphical user interface, or other user interface of any suitable type although this is not essential. 
         [0073]    The term ‘computer’ is used herein to refer to any device with processing capability such that it can execute instructions. Those skilled in the art will realize that such processing capabilities are incorporated into many different devices and therefore the term ‘computer’ includes PCs, servers, mobile telephones, personal digital assistants and many other devices. 
         [0074]    The methods described herein may be performed by software in machine readable form on a tangible storage medium. The software can be suitable for execution on a parallel processor or a serial processor such that the method steps may be carried out in any suitable order, or substantially simultaneously. 
         [0075]    This acknowledges that software can be a valuable, separately tradable commodity. It is intended to encompass software, which runs on or controls “dumb” or standard hardware, to carry out the desired functions. It is also intended to encompass software which “describes” or defines the configuration of hardware, such as HDL (hardware description language) software, as is used for designing silicon chips, or for configuring universal programmable chips, to carry out desired functions. 
         [0076]    Those skilled in the art will realize that storage devices utilized to store program instructions can be distributed across a network. For example, a remote computer may store an example of the process described as software. A local or terminal computer may access the remote computer and download a part or all of the software to run the program. Alternatively, the local computer may download pieces of the software as needed, or execute some software instructions at the local terminal and some at the remote computer (or computer network). Those skilled in the art will also realize that by utilizing conventional techniques known to those skilled in the art that all, or a portion of the software instructions may be carried out by a dedicated circuit, such as a DSP, programmable logic array, or the like. 
         [0077]    Any range or device value given herein may be extended or altered without losing the effect sought, as will be apparent to the skilled person. 
         [0078]    It will be understood that the benefits and advantages described above may relate to one embodiment or may relate to several embodiments. The embodiments are not limited to those that solve any or all of the stated problems or those that have any or all of the stated benefits and advantages. It will further be understood that reference to ‘an’ item refers to one or more of those items. 
         [0079]    The steps of the methods described herein may be carried out in any suitable order, or simultaneously where appropriate. Additionally, individual blocks may be deleted from any of the methods without departing from the spirit and scope of the subject matter described herein. Aspects of any of the examples described above may be combined with aspects of any of the other examples described to form further examples without losing the effect sought. 
         [0080]    The term ‘comprising’ is used herein to mean including the method blocks or elements identified, but that such blocks or elements do not comprise an exclusive list and a method or apparatus may contain additional blocks or elements. 
         [0081]    It will be understood that the above description of a preferred embodiment is given by way of example only and that various modifications may be made by those skilled in the art. The above specification, examples and data provide a complete description of the structure and use of exemplary embodiments of the invention. Although various embodiments of the invention have been described above with a certain degree of particularity, or with reference to one or more individual embodiments, those skilled in the art could make numerous alterations to the disclosed embodiments without departing from the spirit or scope of this invention.