def calculate_score(self, comparison_pairs):
"""
Calculate scores for a set of comparison_pairs
:param comparison_pairs: array of comparison_pairs
:return: dictionary key -> ScoredObject
"""
self.storage = {}
self.opponents = {}
elo.setup()
keys = self.get_keys_from_comparison_pairs(comparison_pairs)
# create default ratings for every available key
for key in keys:
self.storage[key] = ScoredObject(
key=key,
score=elo.Rating(),
variable1=elo.Rating(),
variable2=None,
rounds=0,
opponents=0,
wins=0,
loses=0
)
self.opponents[key] = set()
# calculate rating for every match
for comparison_pair in comparison_pairs:
key1 = comparison_pair.key1
key2 = comparison_pair.key2
winner = comparison_pair.winner
# skip incomplete comparisosns
if winner is None:
self._update_rounds_only(key1)
self._update_rounds_only(key2)
continue
r1 = self.storage[key1].score
r2 = self.storage[key2].score
winner_key1 = winner == ComparisonWinner.key1
winner_key2 = winner == ComparisonWinner.key2
if winner_key1:
r1, r2 = elo.rate_1vs1(r1, r2)
elif winner_key2:
r2, r1 = elo.rate_1vs1(r2, r1)
elif winner == ComparisonWinner.draw:
r1, r2 = elo.rate_1vs1(r1, r2, drawn=True)
else:
raise InvalidWinnerException
self._update_rating(key1, r1, key2, winner_key1, winner_key2)
self._update_rating(key2, r2, key1, winner_key2, winner_key1)
# return comparison results
return self.storage
def calculate_score(self, comparison_pairs):
"""
Calculate scores for a set of comparison_pairs
:param comparison_pairs: array of comparison_pairs
:return: dictionary key -> ScoredObject
"""
self.storage = {}
self.opponents = {}
elo.setup()
keys = self.get_keys_from_comparison_pairs(comparison_pairs)
# create default ratings for every available key
for key in keys:
self.storage[key] = ScoredObject(key=key,
score=elo.Rating(),
variable1=elo.Rating(),
variable2=None,
rounds=0,
opponents=0,
wins=0,
loses=0)
self.opponents[key] = set()
# calculate rating for every match
for comparison_pair in comparison_pairs:
key1 = comparison_pair.key1
key2 = comparison_pair.key2
winner = comparison_pair.winner
# skip incomplete comparisosns
if winner is None:
self._update_rounds_only(key1)
self._update_rounds_only(key2)
continue
r1 = self.storage[key1].score
r2 = self.storage[key2].score
winner_key1 = winner == ComparisonWinner.key1
winner_key2 = winner == ComparisonWinner.key2
if winner_key1:
r1, r2 = elo.rate_1vs1(r1, r2)
elif winner_key2:
r2, r1 = elo.rate_1vs1(r2, r1)
elif winner == ComparisonWinner.draw:
r1, r2 = elo.rate_1vs1(r1, r2, drawn=True)
else:
raise InvalidWinnerException
self._update_rating(key1, r1, key2, winner_key1, winner_key2)
self._update_rating(key2, r2, key1, winner_key2, winner_key1)
# return comparison results
return self.storage
def compute_score(state, team_1_score, team_2_score, points_difference):
"""
State contains the outcome of the game between team_1 and team_2.
It is "WIN" if player 1 wins, "LOSS" if he looses and "DRAW" otherwise.
"""
# +1 to avoid having a k_factor of 0 when there is a DRAW.
elo.setup(k_factor=BASE_K_FACTOR * (points_difference + 1))
if state == "WIN":
scores = elo.rate_1vs1(team_1_score, team_2_score)
elif state == "LOSS":
scores = elo.rate_1vs1(team_2_score, team_1_score)[::-1]
else:
scores = elo.rate_1vs1(team_1_score, team_2_score, drawn=True)
return scores
afficher = True
elo_de_depart = 1000
vaillant =elo_de_depart #4405
gladiator =elo_de_depart #4406
fusion =elo_de_depart #4524
excelsior = elo_de_depart #4403
spitfire = elo_de_depart #4410
uprising =elo_de_depart #4402
mahyem = elo_de_depart # 4407
dragon =elo_de_depart #4408
choc = elo_de_depart #4404
dynastie = elo_de_depart #4409
fuel =elo_de_depart #4523
outlaw = elo_de_depart #4525
elo.setup(k_factor=100, initial=elo_de_depart, beta=110, env=None)
for i in range( nbMatch ):
#if afficher == True :
#print(i)
if i == 205 or i==208 or i ==276 or i== 289 :
if afficher == True :
print("match non chargé")
else :
donnematch= match[i]["competitors"]
equipe1 = donnematch[0]["id"]
equipe2 = donnematch[1]["id"]
#on cherche le winer
if equipe1 == 4405 : #valliantwin
elo1 = vaillant
def calculate_score_1vs1(self, key1_scored_object, key2_scored_object, winner, other_comparison_pairs):
"""
Calculates the scores for a new 1vs1 comparison without re-calculating all previous scores
:param key1_scored_object: Contains score parameters for key1
:param key2_scored_object: Contains score parameters for key2
:param winner: indicates the comparison winner
:param other_comparison_pairs: Contains all previous comparison_pairs that the 2 keys took part in.
This is a subset of all comparison pairs and is used to calculate round, wins, loses, and opponent counts
:return: tuple of ScoredObject (key1, key2)
"""
self.storage = {}
self.opponents = {}
elo.setup()
key1 = key1_scored_object.key
key2 = key2_scored_object.key
# Note: if value are None, elo.Rating will use default rating 1400
r1 = elo.Rating(
value=key1_scored_object.variable1
)
r2 = elo.Rating(
value=key2_scored_object.variable1
)
if winner == ComparisonWinner.key1:
r1, r2 = elo.rate_1vs1(r1, r2)
elif winner == ComparisonWinner.key2:
r2, r1 = elo.rate_1vs1(r2, r1)
elif winner == ComparisonWinner.draw:
r1, r2 = elo.rate_1vs1(r1, r2, drawn=True)
else:
raise InvalidWinnerException
for key in [key1, key2]:
self.opponents[key] = set()
self.storage[key] = ScoredObject(
key=key,
score=r1 if key == key1 else r2,
variable1=r1 if key == key1 else r2,
variable2=None,
rounds=0,
opponents=0,
wins=0,
loses=0
)
# calculate opponents, wins, loses, rounds for every match for key1 and key2
for comparison_pair in (other_comparison_pairs + [ComparisonPair(key1, key2, winner)]):
cp_key1 = comparison_pair.key1
cp_key2 = comparison_pair.key2
cp_winner = comparison_pair.winner
cp_winner_key1 = cp_winner == ComparisonWinner.key1
cp_winner_key2 = cp_winner == ComparisonWinner.key2
if cp_key1 == key1 or cp_key1 == key2:
if cp_winner is None:
self._update_rounds_only(cp_key1)
else:
self._update_result_stats(cp_key1, cp_key2, cp_winner_key1, cp_winner_key2)
if cp_key2 == key1 or cp_key2 == key2:
if cp_winner is None:
self._update_rounds_only(cp_key2)
else:
self._update_result_stats(cp_key2, cp_key1, cp_winner_key2, cp_winner_key1)
return (self.storage[key1], self.storage[key2])
def calculate_score_1vs1(self, key1_scored_object, key2_scored_object,
winner, other_comparison_pairs):
"""
Calculates the scores for a new 1vs1 comparison without re-calculating all previous scores
:param key1_scored_object: Contains score parameters for key1
:param key2_scored_object: Contains score parameters for key2
:param winner: indicates the comparison winner
:param other_comparison_pairs: Contains all previous comparison_pairs that the 2 keys took part in.
This is a subset of all comparison pairs and is used to calculate round, wins, loses, and opponent counts
:return: tuple of ScoredObject (key1, key2)
"""
self.storage = {}
self.opponents = {}
elo.setup()
key1 = key1_scored_object.key
key2 = key2_scored_object.key
# Note: if value are None, elo.Rating will use default rating 1400
r1 = elo.Rating(value=key1_scored_object.variable1)
r2 = elo.Rating(value=key2_scored_object.variable1)
if winner == ComparisonWinner.key1:
r1, r2 = elo.rate_1vs1(r1, r2)
elif winner == ComparisonWinner.key2:
r2, r1 = elo.rate_1vs1(r2, r1)
elif winner == ComparisonWinner.draw:
r1, r2 = elo.rate_1vs1(r1, r2, drawn=True)
else:
raise InvalidWinnerException
for key in [key1, key2]:
self.opponents[key] = set()
self.storage[key] = ScoredObject(
key=key,
score=r1 if key == key1 else r2,
variable1=r1 if key == key1 else r2,
variable2=None,
rounds=0,
opponents=0,
wins=0,
loses=0)
# calculate opponents, wins, loses, rounds for every match for key1 and key2
for comparison_pair in (other_comparison_pairs +
[ComparisonPair(key1, key2, winner)]):
cp_key1 = comparison_pair.key1
cp_key2 = comparison_pair.key2
cp_winner = comparison_pair.winner
cp_winner_key1 = cp_winner == ComparisonWinner.key1
cp_winner_key2 = cp_winner == ComparisonWinner.key2
if cp_key1 == key1 or cp_key1 == key2:
if cp_winner is None:
self._update_rounds_only(cp_key1)
else:
self._update_result_stats(cp_key1, cp_key2, cp_winner_key1,
cp_winner_key2)
if cp_key2 == key1 or cp_key2 == key2:
if cp_winner is None:
self._update_rounds_only(cp_key2)
else:
self._update_result_stats(cp_key2, cp_key1, cp_winner_key2,
cp_winner_key1)
return (self.storage[key1], self.storage[key2])
