def newRating(mu=None, sigma=None):
if mu and sigma:
return trueskill.Rating(mu=mu, sigma=sigma)
elif mu:
return trueskill.Rating(mu=mu, sigma=env.sigma)
else:
return env.create_rating()
def make_matchups(workers_to_match, project_group_id, review_project,
inter_task_review, match_group_id, batch_id):
matched_workers = []
for index in xrange(0, len(workers_to_match)):
if workers_to_match[index] not in matched_workers:
if len(workers_to_match) - len(matched_workers) == 1:
is_last_worker = True
start = 0
else:
is_last_worker = False
start = index + 1
first_worker = workers_to_match[index]
first_score = trueskill.Rating(mu=first_worker['score'].mu,
sigma=first_worker['score'].sigma)
best_quality = 0
second_worker = None
is_intertask_match = None
for j in xrange(start, len(workers_to_match)):
if is_last_worker or workers_to_match[j] not in matched_workers:
second_score = trueskill.Rating(
mu=workers_to_match[j]['score'].mu,
sigma=workers_to_match[j]['score'].sigma)
quality = trueskill.quality_1vs1(first_score, second_score)
if quality > best_quality:
is_intertask_match = False
best_quality = quality
second_worker = workers_to_match[j]
if second_worker is not None:
matched_workers.append(first_worker)
if not is_intertask_match:
matched_workers.append(second_worker)
create_review_task(first_worker, second_worker, review_project,
match_group_id, batch_id)
def evaluate_game(game: Game) -> float:
"""
Returns the expected win probability of the blue team over the red team
"""
blue_team_ratings = [
trueskill.Rating(mu=p.trueskill_mu, sigma=p.trueskill_sigma)
for p in game.teams.BLUE
]
red_team_ratings = [
trueskill.Rating(mu=p.trueskill_mu, sigma=p.trueskill_sigma)
for p in game.teams.RED
]
delta_mu = sum(r.mu
for r in blue_team_ratings) - sum(r.mu
for r in red_team_ratings)
sum_sigma = sum(
r.sigma**2
for r in itertools.chain(blue_team_ratings, red_team_ratings))
size = len(blue_team_ratings) + len(red_team_ratings)
denominator = math.sqrt(size * (trueskill.BETA * trueskill.BETA) +
sum_sigma)
ts = trueskill.global_env()
return ts.cdf(delta_mu / denominator)
def update_trueskill(game: Game, session):
"""
Updates the player’s rating based on the game’s result
"""
blue_team_ratings = {
participant.player.ratings[participant.role]:
trueskill.Rating(mu=participant.trueskill_mu,
sigma=participant.trueskill_sigma)
for participant in game.teams.BLUE
}
red_team_ratings = {
participant.player.ratings[participant.role]:
trueskill.Rating(mu=participant.trueskill_mu,
sigma=participant.trueskill_sigma)
for participant in game.teams.RED
}
if game.winner == "BLUE":
new_ratings = trueskill.rate([blue_team_ratings, red_team_ratings])
else:
new_ratings = trueskill.rate([red_team_ratings, blue_team_ratings])
for ratings in new_ratings:
for player_rating in ratings:
# This is the PlayerRating object
player_rating.trueskill_mu = ratings[player_rating].mu
player_rating.trueskill_sigma = ratings[player_rating].sigma
session.merge(player_rating)
def setUp(self):
self.player_1_id = ObjectId()
self.player_1_name = 'gaR'
self.player_1_aliases = ['gar', 'garr', 'garpr']
self.player_1_rating = {
'norcal': TrueskillRating(),
'texas': TrueskillRating(trueskill_rating=trueskill.Rating(mu=10, sigma=1))
}
self.player_1_regions = ['norcal', 'texas']
self.player_2_id = ObjectId()
self.player_2_name = 'MIOM | SFAT'
self.player_2_aliases = ['miom | sfat', 'sfat', 'miom|sfat']
self.player_2_rating = {'norcal': TrueskillRating(trueskill_rating=trueskill.Rating(mu=30, sigma=2))}
self.player_2_regions = ['norcal', 'socal']
self.player_1 = Player(self.player_1_name, self.player_1_aliases, self.player_1_rating, self.player_1_regions, id=self.player_1_id)
self.player_1_missing_id = Player(self.player_1_name, self.player_1_aliases, self.player_1_rating, self.player_1_regions)
self.player_2 = Player(self.player_2_name, self.player_2_aliases, self.player_2_rating, self.player_2_regions, id=self.player_2_id)
self.player_1_json_dict = {
'_id': self.player_1_id,
'name': self.player_1_name,
'aliases': self.player_1_aliases,
'ratings': {region: rating.get_json_dict() for region, rating in self.player_1_rating.iteritems()},
'regions': self.player_1_regions
}
self.player_1_json_dict_missing_id = {
'name': self.player_1_name,
'aliases': self.player_1_aliases,
'ratings': {region: rating.get_json_dict() for region, rating in self.player_1_rating.iteritems()},
'regions': self.player_1_regions
}
def cal_TrueSkill_demo(args):
data, params, big_zero = args[0], args[1], args[2]
user = defaultdict(ts.Rating)
goal = defaultdict(ts.Rating)
for i in data.iterrows():
rows = i[1]
user[rows['uid']] = ts.Rating(rows['u_player'], 3.0)
goal[rows['gid']] = ts.Rating(rows['g_player'], 3.0)
for i in data.iterrows():
idx = i[0]
item = i[1]
# 对每一条迭代进来的记录，分别初始化uid和pid的能力值，然后用上式计算。
u_player = user[item['uid']]
g_player = goal[item['gid']]
# 核心句，计算一次做题提交之后，trueskill的变化。根据user做题的对错情况，决定这个delta数值是正还是负。
data.loc[idx, 'ts_pts'] = (g_player.mu / u_player.mu) * norm_duration(
item, idx, u_player, g_player, data, params, big_zero)
# 记录即时的goal与user值，是为了后面计算compensate
data.loc[idx, 'temp_g'] = g_player.mu
data.loc[idx, 'temp_u'] = u_player.mu
if item['corr']:
u_player, g_player = ts.rate_1vs1(u_player, g_player)
else:
g_player, u_player = ts.rate_1vs1(g_player, u_player)
user[item['uid']] = u_player
goal[item['gid']] = g_player
return user, goal, data
def get_skill(userid, guildid):
'''
Returns the TrueSkill rating of a discord user.
Will initialize skill if none is found.
:param userid: Discord userid to find
:return: stored TrueSkill rating object of userid
'''
userid = str(userid)
guildid = str(guildid)
# check cache first
if guildid not in ratings_cache:
ratings_cache[guildid] = {}
if userid in ratings_cache[guildid]:
return ratings_cache[guildid][userid]
print(f'Cache Miss: guildid = {guildid} userid = {userid}')
with shelve.open(str(guildid), writeback=True) as db:
if 'ratings' not in db:
db['ratings'] = {}
ratings = db['ratings']
if userid in ratings:
mu, sigma = ratings[userid]
return ts.Rating(float(mu), float(sigma))
new_rating = ts.Rating()
ratings_cache[guildid][userid] = new_rating
ratings[userid] = new_rating.mu, new_rating.sigma
db['ratings'][userid] = new_rating.mu, new_rating.sigma
return new_rating
def add_game(session, winner_id, loser_id, submitted_by_id):
if winner_id == loser_id:
raise Exception("can't play yourself")
winner = session.query(User).get(winner_id)
loser = session.query(User).get(loser_id)
submitted_by = session.query(User).get(submitted_by_id)
winner_rating, loser_rating = trueskill.rate_1vs1(
trueskill.Rating(winner.elo), trueskill.Rating(loser.elo))
winner_elo, loser_elo = winner_rating.mu, loser_rating.mu
# verify created at
new_game = Game(
winner=winner,
loser=loser,
submitted_by=submitted_by,
winner_elo_score=winner_elo,
loser_elo_score=loser_elo,
)
winner.elo = winner_elo
loser.elo = loser_elo
winner.wins = winner.wins + 1
loser.losses = loser.losses + 1
session.add_all([new_game, winner, loser])
return new_game
def set_outcome(self, request, league_id, team, pk=None):
is_admin = User.objects.all().get(username=request.user).is_superuser
if is_admin:
try:
scrimmage = Scrimmage.objects.all().get(pk=pk)
except:
return Response({'message': 'Scrimmage does not exist.'},
status.HTTP_404_NOT_FOUND)
if 'status' in request.data:
sc_status = request.data['status']
if sc_status == "redwon" or sc_status == "bluewon":
scrimmage.status = sc_status
if scrimmage.ranked: # TODO check if ranked
# update rankings based on trueskill algoirthm
# get team info
rteam = self.get_team(league_id, scrimmage.red_team_id)
bteam = self.get_team(league_id,
scrimmage.blue_team_id)
won = rteam if sc_status == "redwon" else bteam
lost = rteam if sc_status == "bluewon" else bteam
# store previous mu in scrimmage
scrimmage.blue_mu = bteam.mu
scrimmage.red_mu = rteam.mu
# get mu and sigma
muW = won.mu
sdW = won.sigma
muL = lost.mu
sdL = lost.sigma
winner = trueskill.Rating(mu=muW, sigma=sdW)
loser = trueskill.Rating(mu=muL, sigma=sdL)
# applies trueskill algorithm & update teams with new scores
wScore, lScore = trueskill.rate_1vs1(winner, loser)
won.mu = wScore.mu
won.sigma = wScore.sigma
lost.mu = lScore.mu
lost.sigma = lScore.sigma
won.save()
lost.save()
scrimmage.save()
return Response({'status': sc_status}, status.HTTP_200_OK)
else:
return Response(
{
'message':
'Set scrimmage to pending/queued/cancelled with accept/reject/cancel api calls'
}, status.HTTP_400_BAD_REQUEST)
else:
return Response({'message': 'Status not specified.'},
status.HTTP_400_BAD_REQUEST)
else:
return Response(
{'message': 'make this request from server account'},
status.HTTP_401_UNAUTHORIZED)
def update_trueskill_by_match(match):
w_ratings = []
l_ratings = []
for p in match.winning_players:
mu, sigma = p.get_current_trueskill()
w_ratings.append(ts.Rating(mu, sigma))
for p in match.losing_players:
mu, sigma = p.get_current_trueskill()
l_ratings.append(ts.Rating(mu, sigma))
rating_groups = [w_ratings, l_ratings]
new_ratings = ts.rate(rating_groups, ranks=[0, 1])
players = match.winning_players + match.losing_players
new_ratings_flat = [item for sublist in new_ratings for item in sublist]
for player, rating in zip(players, new_ratings_flat):
r_m = Rating(
user=player,
match=match,
rating_type='trueskill_mu',
rating_value=rating.mu,
timestamp=match.timestamp,
)
r_s = Rating(
user=player,
match=match,
rating_type='trueskill_sigma',
rating_value=rating.sigma,
timestamp=match.timestamp,
)
db.session.add_all([r_m, r_s])
db.session.commit()
def add_new_player(self, name, token_id, is_admin, is_hidden):
self.database.execute(
"INSERT INTO players (name, token_id, skill_mu, skill_sigma, is_admin, is_hidden) VALUES(?, ?, ?, ?, ?, ?)",
(name, token_id, trueskill.Rating().mu, trueskill.Rating().sigma,
is_admin, is_hidden))
self.database.commit()
print("Added new player: " + name)
def compute_player_skills(rounds: [RoundRow], teams: [dict],
current_ratings: {int: trueskill.Rating} = None) \
-> ({int: trueskill.Rating}, [SkillHistory]):
ratings = {}
if current_ratings is not None:
ratings.update(current_ratings)
skill_history = []
for round in rounds:
rating_groups = (
{
player_id: ratings.get(player_id, trueskill.Rating())
for player_id in teams[round.winner]
},
{
player_id: ratings.get(player_id, trueskill.Rating())
for player_id in teams[round.loser]
},
)
new_ratings = trueskill.rate(rating_groups)
for rating in new_ratings:
ratings.update(rating)
for player_id, skill in rating.items():
skill_history.append(
SkillHistory(round_id=round.round_id,
player_id=player_id,
skill=skill))
return ratings, skill_history
def calculate_mmr(self, r):
if not r:
return None
#get current rating
mmr_team0 = OrderedDict(
) # key = account | val = list(current_mmr, new_mmr)
mmr_team1 = OrderedDict()
for player in r.team0.memberList:
mmr_team0[r.players[player]][0] = trueskill.Rating(
self.get_mmr(r.players[player].toonHandle))
for player in r.team1.memberList:
mmr_team1[r.players[player]][0] = trueskill.Rating(
self.get_mmr(r.players[player].toonHandle))
ratings = trueskill.rate([[x for x in mmr_team0.itervalues()],
[x for x in mmr_team1.itervalues()]],
ranks=[r.team0.isLoser, r.team0.isWinner])
for player in r.team0.memberList:
mmr_team0[player][1] = ratings[player]
for player in r.team1.memberList:
mmr_team1[player][1] = ratings[player + len(r.team0.memberList) -
1]
return mmr_team0, mmr_team1
def compute_ratings(matches):
ratings = {}
histories = {}
new_player_history = []
stats = {}
new_player_stats = []
for _, match in matches.iterrows():
for name in set(itertools.chain(stats.keys(), match['player_stats'])):
stats.setdefault(name, new_player_stats[:])
if name in match['player_stats']:
stats[name].append(match['player_stats'][name])
else:
stats[name].append(None)
new_player_stats.append(None)
new_ratings = trueskill.rate((
{
name: ratings.get(name, trueskill.Rating())
for name in match["win"]
},
{
name: ratings.get(name, trueskill.Rating())
for name in match["loss"]
},
))
for new_rating in new_ratings:
ratings.update(new_rating)
new_player_history.append(trueskill.Rating())
for name in ratings:
histories.setdefault(name, new_player_history[:])
histories[name].append(ratings[name])
rows = [(name, rating, stats[name], histories[name])
for name, rating in ratings.items()]
ratings = pd.DataFrame.from_records(
rows,
columns=["Name", "trueskill.Rating", "stats", "history"],
index="Name")
ratings.index.name = None
boundaries = compute_division_boundaries()
ratings["μ"] = ratings["trueskill.Rating"].apply(lambda rating: rating.mu)
ratings["σ"] = ratings["trueskill.Rating"].apply(
lambda rating: rating.sigma)
ratings["Rating"] = ratings["trueskill.Rating"].apply(
lambda rating: trueskill.expose(rating))
ratings["Rank"] = ratings["Rating"].apply(
lambda rating: find_division(boundaries, rating))
ratings["Record"] = ratings["stats"].apply(
lambda stats: compute_record(stats))
ratings["Streak"] = ratings["stats"].apply(
lambda stats: compute_streak(stats))
ratings["Champs"] = ratings["stats"].apply(
lambda stats: tuple(game["champ"] for game in stats if game))
ratings.sort_values("Rating", ascending=False, inplace=True)
return ratings
def rate2p(self, r_a, r_b, score):
(r_a2, r_b2)\
= super(BoundedTrueSkillSystem, self).rate2p(r_a, r_b, score)
if r_a2.mu < self.mu_lower_bound:
r_a2 = trueskill.Rating(self.mu_lower_bound, r_a2.sigma)
if r_b2.mu < self.mu_lower_bound:
r_b2 = trueskill.Rating(self.mu_lower_bound, r_b2.sigma)
return (r_a2, r_b2)
def rankEvent(roster, year, event):
testurl = BWurl + str(year) + codeToBW[event]
origSeed = {}
for i in range(len(roster), 64):
print("only should hit this if below 64 teams")
roster[i + 1] = [Player(0, 'Bye', 0, 0.001).db()] * 4
for i in range(1, len(roster) + 1):
origSeed[i] = i
# add logic for >64 teams, day 1 stuff
print('Eval...', testurl)
r1 = requests.get(testurl)
soup = BeautifulSoup(r1.content, 'html.parser')
soup_rows = soup.find_all('div', class_='bw_ko_match')
winnerList = []
for div in soup_rows:
winner = div.find_all('div', attrs={'class': 'winner'})
win = [i['seed'] for i in winner]
#print(win[0],div['low_seed'], div['high_seed'],'\n')
#win[0] = input(div['low_seed'] + ' vs. ' + div['high_seed'])
winnerList.append((win[0], div['low_seed'], div['high_seed']))
for i in winnerList: # tuple of winner, low seed, high seed
#print('yes! ', i)
upset = (i[0] != i[1])
winlose = [1, 0] if upset else [0, 1]
# original seeds
o1 = int(origSeed[int(i[1])])
o2 = int(origSeed[int(i[2])])
#print(roster[o1],roster[o2])
# iterate over rosters, get player TS info
list1 = [ts.Rating(x['mu'], x['sigma']) for x in roster[o1]]
list2 = [ts.Rating(x['mu'], x['sigma']) for x in roster[o2]]
try:
#print(i,list1,list2)
newRanks = ts.rate((list1, list2), winlose)
#print('----got here----', newRanks)
addToDB(newRanks, roster[o1], roster[o2])
except KeyError:
print('keyerror', i, list1, list2)
pass
except ValueError:
print(
'Team with no players due to bogus player numbers. Ignoring.')
if upset:
origSeed[int(i[1])] = int(i[0])
def parse_rating(score):
if not score:
score = trueskill.Rating()
else:
score = json.loads(score)
_ = trueskill.Rating(mu=score['mu'], sigma=score['sigma'])
score = _
return score
def evaluate(players,
board_size,
depths=[4, 4],
amount=1,
t_run=7.2,
N=1e9,
cp=1):
"""
Evaluation between two methods in players, based on TrueSkill evaluation
"""
#initialize rating
if len(players) == 2:
r1 = ts.Rating()
r2 = ts.Rating()
print()
print('rating 1: ', r1)
print('rating 2: ', r2)
print()
r1, r2, save = match(players, board_size, depths, r1, r2, amount,
t_run, N, cp)
print()
print('rating 1: ', r1)
print('rating 2: ', r2)
print()
elif len(players) == 3:
r1 = ts.Rating()
r2 = ts.Rating()
r3 = ts.Rating()
print("Evaluating players: {} {} width depth: {} {}".format(
players[0], players[1], depths[0], depths[1]))
r1, r2, save_1 = match([players[0], players[1]], board_size, depths,
r1, r2, amount, t_run, N, cp)
print("Evaluating players: {} {} width depth: {} {}".format(
players[0], players[2], depths[0], depths[2]))
r1, r3, save_2 = match([players[0], players[2]], board_size, depths,
r1, r3, amount, t_run, N, cp)
print("Evaluating players: {} {} width depth: {} {}".format(
players[1], players[2], depths[1], depths[2]))
r2, r3, save_3 = match([players[1], players[2]], board_size, depths,
r2, r3, amount, t_run, N, cp)
print()
print('rating 1: ', r1)
print('rating 2: ', r2)
print('rating 3: ', r3)
print()
save = np.hstack((r1, r2, r3))
return save
def rate2p(self, r_a, r_b, score):
(r_a2, r_b2) = super(NoisyTrueSkillSystem,
self).rate2p(r_a, r_b, score)
rand_a = 2 * self.noise_factor * (random.random() - 0.5) * (r_a2.mu -
r_a.mu)
rand_b = 2 * self.noise_factor * (random.random() - 0.5) * (r_b2.mu -
r_b.mu)
r_a2 = trueskill.Rating(r_a2.mu + rand_a, r_a2.sigma)
r_b2 = trueskill.Rating(r_b2.mu + rand_b, r_b2.sigma)
return (r_a2, r_b2)
def check_players(match, racers_dict):
winner = match.winner.name
loser = match.loser.name
if winner not in racers_dict:
racers_dict[winner]['rating'] = trueskill.Rating(25)
racers_dict[winner]['matches_played'] = 0
racers_dict[winner]['tournaments_played'] = 0
if loser not in racers_dict:
racers_dict[loser]['rating'] = trueskill.Rating(25)
racers_dict[loser]['matches_played'] = 0
racers_dict[loser]['tournaments_played'] = 0
def load_ratings(
path: str,
clients: List[Tuple[str,
Client]]) -> List[Tuple[str, Client, ts.Rating]]:
ratings = {}
if os.path.exists(path):
with open(path, 'r') as f:
for name, (mu, sigma) in json.load(f).items():
ratings[name] = ts.Rating(mu, sigma)
for name, _ in clients:
if name not in ratings:
ratings[name] = ts.Rating()
return [(n, c, ratings[n]) for (n, c) in clients]
def __init__(self, run_folder, self_play):
self.run_folder = run_folder
# Server from SEPIA
self.server = EnvironmentServiceImpl(self.env_callback,
self.winner_callback)
# Which two agents are currently being played against each other
self.active_agents = [0, 0]
# List of agents in tournament. Will be ~50MB total
self.agents = []
# List of agent associated data, such as names, used for saving later
self.agents_data = []
# Trueskill ratings for each agent
self.ratings = []
# How many times each agent as been played against each other
self.trials = 0
# How many total trials to do before we are done
self.num_trials = 200
# True if player 1 is a sepia agent, not another one of our agents
self.playing_against_sepia = not self_play
# How many game steps have occurred
self.iterations = 0
# Start time of run
self.start_time = time.time()
# Load agents from disk
self.load_agents()
# Wins, losses, ties
self.win_stats = np.zeros((len(self.agents), 3))
# Set up the trueskill environment and make it a global env
env = trueskill.TrueSkill(mu=25.0,
sigma=8.33,
beta=4.17,
tau=0,
draw_probability=0.05)
env.make_as_global()
# Initialize ratings to be all the same
self.ratings = [trueskill.Rating() for _ in range(len(self.agents))]
self.sepia_rating = trueskill.Rating(30, 0.00000000001)
def _get_player_ratings_from_ddb(table, names):
players = []
for player in names:
result = table.get_item(table,
TableName=PLAYER_TABLE_NAME,
Key={"PlayerName": player})
if "Item" in result:
players.append(
trueskill.Rating(float(result["Item"]["mu"]),
float(result["Item"]["sigma"])))
else:
players.append(trueskill.Rating())
return players
def test_3_player_draw():
r1 = trueskill.Rating()
r2 = trueskill.Rating()
r3 = trueskill.Rating()
sigma0 = r1.sigma
[(r1, ), (r2, ), (r3, )] = trueskill.transform_ratings([(r1, ), (r2, ),
(r3, )],
ranks=(1, 1, 3))
# We would hope it would be zero, but trueskill isn't that accurate.
assert abs(r1.mu - r2.mu) < 0.01
assert r1.mu > r3.mu
assert r2.mu > r3.mu
for rating in [r1, r2, r3]:
assert rating.sigma < sigma0
def bayes_func(unratePer):#, days):#, par=400, inf=True):
global ratingDfMain, ratingDf
df = pd.read_csv('../data/csgoEloDS.csv', sep=';')
# print df.describe()
df['date'] = df['date'].apply(lambda x: dt.datetime.strptime(x, "%Y-%m-%d %H:%M:%S"))
# df = df.sort_values('date').reset_index(drop=True)
#df['difScore'] = df['difScore'].apply(lambda x: 0.5 if x==0 else 0 if x<0 else 1)
df.loc[~df.isnull().any(axis=1), 'difScore'] = df.loc[~df.isnull().any(axis=1), 'difScore']/32.0 + 0.5
# df['difScore'] = df['difScore']/32.0 + 0.5
df['ratingA'] = 25
df['ratingB'] = 25
df['rdA'] = 6.458
df['rdB'] = 6.458
#df['sigmaA'] = 0.06
#df['sigmaB'] = 0.06
#print df.info()
# params = 7
# unratePer = 112
# print df.describe()
# raise 'sdfsdf'
# ratePer = 8
# params = [df, winBonus, params*unratePer, tau, params*ratePer]
params = [df, unratePer, True]
teamIds = np.unique(np.append(df['teamAId'].value_counts().index.values, df['teamBId'].value_counts().index.values))
ratingDfMain = {}
# mindate = df['date'].min()
# maxdate = df['date'].max()
# lcldate = mindate
# print maxdate
for ids in teamIds:
ratingDfMain[ids] = [trueskill.Rating(25, 6.458), 0, trueskill.Rating(25, 6.458)]
# params =
print dt.datetime.today()
print params[1:]
tm = time.time()
dc = ratingCalculation(*params)
print 'time', time.time() - tm, dt.datetime.today()
print dc
# df['probA'] = np.round(df.apply(lambda x: win_probability1(x), axis=1).values, 6)
# df['probB'] = 1 - df['probA'].values
return dc['acc']
return -dc['error']
def add_match(conn, bots, results):
winner = None
for id_str, stats in results['stats'].items():
if stats['rank'] == 1:
winner = int(id_str)
if winner is None:
raise ValueError('Could not detect winner of game')
query = 'insert into games (datetime, winner, participants, results) values (?, ?, ?, ?)'
del results['final_snapshot']
current_time = datetime.datetime.now().isoformat()
conn.execute(query, (current_time, bots[winner]['id'], json.dumps(bots),
json.dumps(results)))
for bot in bots:
history_query = 'insert into rank_history (bot_id, datetime, rank, mu, sigma) values (?, ?, ?, ?, ?)'
conn.execute(
history_query,
(bot['id'], current_time, bot['rank'], bot['mu'], bot['sigma']))
games_played_query = 'update bots set games_played=games_played + 1 where id = ?'
conn.execute(games_played_query, (bot['id'], ))
trueskill.setup(tau=0.008, draw_probability=0.001)
teams = [[trueskill.Rating(mu=bot["mu"], sigma=bot["sigma"])]
for bot in bots]
ranks = [results["stats"][str(b)]["rank"] - 1 for b in range(len(bots))]
new_ratings = trueskill.rate(teams, ranks)
update_query = 'update bots set mu=?, sigma=? where id=?'
for bot, rating in zip(bots, new_ratings):
conn.execute(update_query, (rating[0].mu, rating[0].sigma, bot['id']))
rerank_bots(conn)
def __init__(self, rating_agents, config):
super(ApprenticeHandleDone, self).__init__(
rating_agents,
config
)
board_size = int(config["GLOBAL"]["board_size"])
log_dir = config["GLOBAL"]["log_dir"]
mcts_dir = config["mctsEval"]["dir"]
mcts_dir = mcts_dir.format(board_size=board_size)
mcts_rating_file = config["mctsEval"]["eval_file"]
mcts_rating_file = "/".join([log_dir, mcts_dir, mcts_rating_file])
with open(mcts_rating_file, "r") as ratings_f:
mcts_ratings = json.load(ratings_f)
self.mcts_ratings = {
player.WHITE: dict(),
player.BLACK: dict()
}
for key in self.mcts_ratings:
mus = mcts_ratings[str(int(key))]["mu"]
sigmas = mcts_ratings[str(int(key))]["sigma"]
depths = mcts_ratings[str(int(key))]["depth"]
for mu, sigma, depth in zip(mus, sigmas, depths):
self.mcts_ratings[key][depth] = trueskill.Rating(
mu=mu, sigma=sigma)
def main(games_file: str, ratings_file: str):
# Load data.
players = defaultdict(lambda: ts.Rating())
games = pd.read_csv(games_file)
# Sort data based on date.
games.sort_values(by=[DATE_COLUMN], inplace=True)
games.fillna("", inplace=True)
for _, (date, pl1, pl2, sc1, sc2, pl3, pl4) in games.iterrows():
team1 = []
skills1 = []
team2 = []
skills2 = []
team1, skills1 = append(pl1, players, team1, skills1)
team1, skills1 = append(pl2, players, team1, skills1)
team2, skills2 = append(pl3, players, team2, skills2)
team2, skills2 = append(pl4, players, team2, skills2)
ranks = compute_rank(sc1, sc2)
ratings1, ratings2 = ts.rate([skills1, skills2], ranks=ranks)
update(players, team1, ratings1)
update(players, team2, ratings2)
# Save ratings.
result = []
for name, rating in players.items():
result.append({"Name": name, "Mu": rating.mu, "Sigma": rating.sigma})
df = pd.DataFrame(result)
df.to_csv(ratings_file, index=False)
def rate(self, ratings, ranks):
ratings2 = super(BoundedTrueSkillSystem, self).rate(ratings, ranks)
for i in range(len(ratings2)):
if ratings2[i].mu < self.mu_lower_bound:
ratings2[i] = trueskill.Rating(self.mu_lower_bound,
ratings2[i].sigma)
return ratings2
def set_current_robotic_player(self, id):
self.current_robotic_player_record = self.db.get_robotic_player(id)[0]
self.current_robotic_player_rating = trueskill.Rating(
self.current_robotic_player_record[3],
self.current_robotic_player_record[4])
print("Robot database row {}".format(
self.current_robotic_player_record))
