Beispiel #1
0
def win_probability(a, b):
    deltaMu = sum([x.mu for x in a]) - sum([x.mu for x in b])
    sumSigma = sum([x.sigma**2 for x in a]) + sum([x.sigma**2 for x in b])
    playerCount = len(a) + len(b)
    denominator = math.sqrt(playerCount * (trueskill.BETA * trueskill.BETA) +
                            sumSigma)
    return cdf(deltaMu / denominator)
Beispiel #2
0
 def win_probability(self, rating_a, rating_b):
     from trueskill import BETA
     from math import sqrt
     from trueskill.backends import cdf
     delta_mu = rating_a.mu - rating_b.mu
     denom = sqrt(2 * (BETA * BETA) + pow(rating_a.sigma, 2) \
                  + pow(rating_b.sigma, 2))
     return cdf(delta_mu / denom)
Beispiel #3
0
def predict_win_probability(team_1, team_2):     
    a = [role.rating for role in team_1.ratings]
    b = [role.rating for role in team_2.ratings]                                                 
    deltaMu = sum([x.mu for x in a]) - sum([x.mu for x in b])                   
    sumSigma = sum([x.sigma ** 2 for x in a]) + sum([x.sigma ** 2 for x in b])  
    playerCount = len(a) + len(b)                                               
    denominator = math.sqrt(playerCount * (BETA * BETA) + sumSigma)             
    return cdf(deltaMu / denominator) 
Beispiel #4
0
 def _calculate_win_probability_internal(a: Collection[Rating],
                                         b: Collection[Rating]) -> int:
     delta_mu = sum([x.mu for x in a]) - sum([x.mu for x in b])
     sum_sigma = sum([x.sigma**2 for x in a]) + sum([x.sigma**2 for x in b])
     player_count = len(a) + len(b)
     denominator = max(
         trueskill.DELTA,
         sqrt(player_count * (trueskill.BETA**2) + sum_sigma).real)
     return cdf(delta_mu / denominator)
Beispiel #5
0
 def predict(self, red_alliance, blue_alliance):
     self.init_teams(red_alliance, blue_alliance)
     a = [self.trueskills[t] for t in red_alliance]
     b = [self.trueskills[t] for t in blue_alliance]
     delta_mu = sum([x.mu for x in a]) - sum([x.mu for x in b])
     sum_sigma = sum([x.sigma ** 2 for x in a + b])
     player_count = len(a) + len(b)
     denominator = (player_count * (self.env.beta**2) + sum_sigma) ** 0.5
     return backends.cdf(delta_mu / denominator)
Beispiel #6
0
def win_probability(player_rating, opponent_rating):
    delta_mu = player_rating.mu - opponent_rating.mu
    denom = sqrt(2 * (BETA * BETA) + pow(player_rating.sigma, 2) + pow(opponent_rating.sigma, 2))
    return cdf(delta_mu / denom)
Beispiel #7
0
def Pwin(rAlist=[Rating()],  rBlist=[Rating()]):
    deltaMu = sum([x.mu for x in rAlist]) - sum([x.mu for x in rBlist])
    rsss = sqrt(sum([x.sigma**2 for x in rAlist]) + sum([x.sigma**2 for x in rBlist]))
    return cdf(deltaMu / rsss)
def win_prob(r1, r2):
    delta = r1.mu - r2.mu
    #Perhaps we should weight the uncertainty higher...
    rsss = sqrt(r1.sigma**2 + r2.sigma**2)
    return cdf(delta / rsss)
Beispiel #9
0
def win_probability(player_rating, opponent_rating):
    delta_mu = player_rating.mu - opponent_rating.mu
    denom = sqrt(2 * (BETA * BETA) + pow(player_rating.sigma, 2) + pow(opponent_rating.sigma, 2))
    return cdf(delta_mu / denom)
Beispiel #10
0
 def win_pct(self, player, opp=None):
     return cdf(self.win_stdev(player, opp))
 def win_probability(self, player, opponent):
     delta_mu = player.rating.mu - opponent.rating.mu - calc_draw_margin(self.draw, 2, self.env)
     denom = sqrt(2 * (self.beta * self.beta) + pow(player.rating.sigma, 2) + pow(opponent.rating.sigma, 2))
     return cdf(delta_mu / denom)
Beispiel #12
0
def Pwin(rA=Rating(), rB=Rating()):
    deltaMu = rA.mu - rB.mu
    rsss = sqrt(rA.sigma**2 + rB.sigma**2)
    return cdf(deltaMu/rsss)
Beispiel #13
0
 def Pwin(rA=trueskill.Rating(), rB=trueskill.Rating()):
     deltaMu = rA.mu - rB.mu
     rsss = math.sqrt(rA.sigma**2 + rB.sigma**2)
     _prob = cdf(deltaMu / rsss)
     return _prob