def rate_match(self): """Use TrueSkill to modify players skill""" # TrueSkill setup setup(mu=TRUESKILL_MU, sigma=TRUESKILL_SIGMA, beta=TRUESKILL_BETA, tau=TRUESKILL_TAU) if 'scipy' in backends.available_backends(): # scipy can be used in the current environment backends.choose_backend(backend='scipy') self.player_1_trueskill_mu_before_match = self.player_1.trueskill_mu self.player_1_trueskill_sigma_before_match = self.player_1.trueskill_sigma self.player_2_trueskill_mu_before_match = self.player_2.trueskill_mu self.player_2_trueskill_sigma_before_match = self.player_2.trueskill_sigma player_1_trueskill = Rating(self.player_1_trueskill_mu_before_match, self.player_1_trueskill_sigma_before_match) player_2_trueskill = Rating(self.player_2_trueskill_mu_before_match, self.player_2_trueskill_sigma_before_match) if self.winner == self.player_1: new_player_1_trueskill, new_player_2_trueskill = rate_1vs1( player_1_trueskill, player_2_trueskill) else: new_player_2_trueskill, new_player_1_trueskill = rate_1vs1( player_2_trueskill, player_1_trueskill) self.player_1_trueskill_mu_after_match = new_player_1_trueskill.mu self.player_1_trueskill_sigma_after_match = new_player_1_trueskill.sigma self.player_2_trueskill_mu_after_match = new_player_2_trueskill.mu self.player_2_trueskill_sigma_after_match = new_player_2_trueskill.sigma self.player_1.trueskill_mu = self.player_1_trueskill_mu_after_match self.player_1.trueskill_sigma = self.player_1_trueskill_sigma_after_match self.player_2.trueskill_mu = self.player_2_trueskill_mu_after_match self.player_2.trueskill_sigma = self.player_2_trueskill_sigma_after_match self.player_1.save() self.player_2.save()
def rate_team(self, matches): """ This function runs the TrueSkill rating system to determine the skill estimates of each team. """ trueskill.setup(draw_probability=self.draw_prob(matches)) ratings = dict( zip(self.all_teams, [trueskill.global_env().create_rating()] * len(self.all_teams))) for match in matches: wteam = str(match['Wteam']) lteam = str(match['Lteam']) wscore = match['Wscore'] lscore = match['Lscore'] if wteam in ratings and lteam in ratings: if wscore < lscore: wteam, lteam = lteam, wteam wscore, lscore = lscore, wscore ratings[wteam], ratings[lteam] = \ trueskill.rate_1vs1(ratings[wteam], ratings[lteam], drawn=self.is_equal_score(wscore, lscore)) wscore -= self.vic_margin # while wscore - lscore >= self.vic_margin: # ratings[wteam], ratings[lteam] = \ # trueskill.rate_1vs1(ratings[wteam], ratings[lteam], drawn=self.is_equal_score(wscore, lscore)) # wscore -= self.vic_margin return ratings
def __init__(self, match_data, score_weighting=False): if match_data is None: raise ValueError("Data cannot be null") self._trained = False _, _, team_num_map = process.match_vectors(match_data) self.team_num_map = team_num_map homes = pd.unique(match_data.home_team) aways = pd.unique(match_data.away_team) teams = np.union1d(homes, aways) self.team_ratings = {} for team in teams: self.team_ratings[team] = Rating() self.avg_margin = 0 self.num_draws = 0 trueskill.setup(mu=25.0, sigma=8.333333333333334, beta=4.1666666666666, tau=0.08333333333333334, draw_probability=0.26) self.train(match_data, score_weighting) self.team_skills = np.zeros((len(teams), )) for team in teams: self.team_skills[self.team_num_map[team]] = \ self.team_ratings[team].mu return
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 get_leaderboard(self): self._load_matches() with self._lock: trueskill.setup(backend='scipy', draw_probability=0) for player in self._players.values(): player.rating = trueskill.Rating() for _, match in self._matches.iterrows(): win_update, loss_update = trueskill.rate(( { name: self._players[name].rating for name in match['winners'] }, { name: self._players[name].rating for name in match['losers'] }, )) self._update_player_ratings(win_update) self._update_player_ratings(loss_update) leaderboard = pd.DataFrame([ p.to_series() for p in self._players.values() ]).sort_values('rating', ascending=False) return leaderboard
def __init__(self): trueskill.setup(trueskill.MU, trueskill.SIGMA, trueskill.BETA, trueskill.TAU, draw_probability=0) self.snapshots = { } # self.snapshots[tournament] = {'playername' = , 'trueskill' = } self.matches: [] = [] self.playerscenes = {} self.playerteams = {} self.playerratings = {} self.playertournaments = { } # playertournaments[playername] = ["BB4","KQ30",...] self.playergames = {} self.playerwins = {} self.playerlosses = {} self.incomplete_players = [] # list of playernames w/0 scenes self.tournaments = [] self.tournamentdates = { } # source data only ties matches directly to a date. self.teams = {} # [tournament][team name] = {p1, p2, p3...} self.output_file_name: str = '../PlayerSkill.csv' self.ratings_change_by_opponent = RatingsChangeByOpponent(self.teams) self.ratings_change_by_teammate = RatingsChangeByTeammate(self.teams) self.observers = [ self.ratings_change_by_opponent, self.ratings_change_by_teammate ] self.process_approved_datasets()
async def matchmaking(context): """Finds a player to play against""" discord_id = context.message.author.id mention = context.message.author.mention try: player = Player.objects.get(discord_id=discord_id) except Player.DoesNotExist: await context.send( mention + ' you are not registered in the league!' 'type ' + BOT.command_prefix + 'register <jstris nickname> to register in the league') return # TrueSkill setup setup(mu=TRUESKILL_MU, sigma=TRUESKILL_SIGMA, beta=TRUESKILL_BETA, tau=TRUESKILL_TAU) if 'scipy' in backends.available_backends(): # scipy can be used in the current environment backends.choose_backend(backend='scipy') # Setup the Rating for the asking player rating_asking = Rating(mu=player.trueskill_mu, sigma=player.trueskill_sigma) players = Player.objects.exclude(discord_id=discord_id) best_match = None best_quality = 0.0 for player_match in players: player_rating = Rating(mu=player_match.trueskill_mu, sigma=player_match.trueskill_sigma) quality = quality_1vs1(rating_asking, player_rating) if quality > best_quality: best_quality = quality best_match = player_match await context.send(player.discord_nickname + ' should play against ' + best_match.discord_nickname)
def startEvaluation(self): import trueskill self.home_adv_adjust() trueskill.setup(draw_probability=self.draw_prob()) team_rating = dict( zip(self.teams, [trueskill.global_env().create_rating()] * len(self.teams))) for match in self.regular_matches: wteam = match[self.regular_titles.index('Wteam')] lteam = match[self.regular_titles.index('Lteam')] wscore = match[self.regular_titles.index('Wscore')] lscore = match[self.regular_titles.index('Lscore')] if wteam in team_rating and lteam in team_rating: if wscore < lscore: wteam, lteam = lteam, wteam team_rating[wteam], team_rating[lteam] = trueskill.rate_1vs1(team_rating[wteam], \ team_rating[lteam], drawn = self.is_equal_score(wscore, lscore)) probs = [] for i in range(0, len(teams)): for j in range(i + 1, len(teams)): prob = self.win_probability(team_rating[teams[i]], team_rating[teams[j]]) probs.append(prob) return probs
def init(): global conn, c, last_match dbexists = isfile("database.sqlite3") conn = sqlite3.connect("database.sqlite3") conn.row_factory = sqlite3.Row c = conn.cursor() #set up trueskill here: ts.setup(draw_probability=0.01) if dbexists: try: check_db() except Exception as e: console.display(e) console.terminate() return else: console.display("DATATBASE| Creating new database...") create_tables() c.execute("SELECT pickup_id from pickups ORDER BY pickup_id DESC LIMIT 1") result = c.fetchone() if result: last_match = result[0] else: last_match = -1
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 = {} self.ratings = {} trueskill.setup() keys = self.get_keys_from_comparison_pairs(comparison_pairs) # create default ratings for every available key for key in keys: rating = trueskill.Rating() self.ratings[key] = rating self.opponents[key] = set() self.storage[key] = ScoredObject(key=key, score=trueskill.expose(rating), variable1=rating.mu, variable2=rating.sigma, rounds=0, opponents=0, wins=0, loses=0) # calculate rating by 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.ratings[key1] r2 = self.ratings[key2] key1_winner = winner == ComparisonWinner.key1 key2_winner = winner == ComparisonWinner.key2 if key1_winner: r1, r2 = trueskill.rate_1vs1(r1, r2) elif key2_winner: r2, r1 = trueskill.rate_1vs1(r2, r1) elif winner == ComparisonWinner.draw: r1, r2 = trueskill.rate_1vs1(r1, r2, drawn=True) else: raise InvalidWinnerException self._update_rating(key1, r1, key2, key1_winner, key2_winner) self._update_rating(key2, r2, key1, key2_winner, key1_winner) # return comparison results return self.storage
def setup(): trueskill.setup( mu=50., sigma=50. / 3., beta=50. / 6., tau=50. / 300., draw_probability=.03, )
def test_setup_global_environment(): try: setup(draw_probability=.50) t1, t2 = generate_teams([1, 1]) rated = rate([t1, t2]) assert almost(rated) == [(30.267, 7.077), (19.733, 7.077)] finally: # rollback setup()
def calculate_score(self, comparison_pairs): """ Calculate scores for a set of comparisons :param comparisons: array of :return: dictionary key -> ScoredObject """ self.storage = {} self.opponents = {} self.ratings = {} trueskill.setup() keys = self.get_keys_from_comparison_pairs(comparison_pairs) # create default ratings for every available key for key in keys: rating = trueskill.Rating() self.ratings[key] = rating self.opponents[key] = set() self.storage[key] = ScoredObject( key=key, score=trueskill.expose(rating), variable1=rating.mu, variable2=rating.sigma, rounds=0, opponents=0, wins=0, loses=0, ) # calculate rating by for every match for comparison_pair in comparison_pairs: key1 = comparison_pair.key1 key2 = comparison_pair.key2 winning_key = comparison_pair.winning_key # skip incomplete comparisosns if winning_key is None: self._update_rounds_only(key1) self._update_rounds_only(key2) continue r1 = self.ratings[key1] r2 = self.ratings[key2] if winning_key == comparison_pair.key1: r1, r2 = trueskill.rate_1vs1(r1, r2) elif winning_key == comparison_pair.key2: r2, r1 = trueskill.rate_1vs1(r2, r1) else: raise InvalidWinningKeyException self._update_rating(key1, r1, key2, winning_key) self._update_rating(key2, r2, key1, winning_key) # return comparison results return self.storage
def init(): trueskill.setup( mu=1600, # mu of the prior sigma=400, # sigma of the prior beta=200, # distance to guarantee 76% of winning (rec = sigma/2) tau= 4, # dynamic ratings factor (increases sigma over time) (rec = sigma/100) draw_probability=0.0, # probability of a draw backend=None ) # allows for mpmath/scipy normal distribution implementations
def mm_setup_environment(mu=ELO_AVG_RATING, sigma=ELO_RANK_INCREMENT, beta=ELO_INCREMENT_RANGE, tau=5, draw_prob=0.10): """ Sets up the global environment for Trueskill """ trueskill.setup(mu=mu, sigma=sigma, beta=beta, tau=tau, draw_probability=draw_prob)
def calculate_trueskill(results): trueskill.setup(mu=TRUESKILL_MU, sigma=TRUESKILL_SIGMA, beta=TRUESKILL_BETA, tau=TRUESKILL_TAU, draw_probability=0.0) players = defaultdict(lambda: trueskill.Rating()) players_by_event = defaultdict(dict) outcome_by_event = defaultdict(lambda: defaultdict(list)) accuracy_by_event = defaultdict(list) probability_by_event = defaultdict(list) match_rating_pairs = [] for (event_name, round_no, player_a, player_b, winner) in results: if player_a is None or player_b is None: continue # This is a BYE match if winner is None: outcome_by_event[player_a][event_name].append(0) outcome_by_event[player_b][event_name].append(0) continue # This is a double loss loser = player_a if winner == player_b else player_b rank_winner = trueskill_rank(players[winner]) rank_loser = trueskill_rank(players[loser]) match_rating_pairs.append((rank_winner, rank_loser)) probability = trueskill_win_prob(players[winner], players[loser]) probability_by_event[event_name].append(probability) accuracy = 1.0 if probability > 0.5 else 0.0 accuracy_by_event[event_name].append(accuracy) players[winner], players[loser] = trueskill.rate_1vs1( players[winner], players[loser]) players_by_event[winner][event_name] = trueskill_rank(players[winner]) players_by_event[loser][event_name] = trueskill_rank(players[loser]) outcome_by_event[winner][event_name].append(1) outcome_by_event[loser][event_name].append(0) playerranks = {} for (player_name, rating) in players.items(): playerranks[player_name] = round(trueskill_rank(rating), 2) statistics = { 'players_by_event': players_by_event, 'accuracy_by_event': accuracy_by_event, 'probability_by_event': probability_by_event, 'outcome_by_event': outcome_by_event, 'match_rating_pairs': match_rating_pairs } return (playerranks, statistics)
def generate_true_skill(matches): matches_no = {} forfeits_no = {} for match in matches: for i, player in enumerate(match.players): matches_no[player] = matches_no.get(player, 0) + 1 forfeits_no[player] = forfeits_no.get( player, 0) + (1 if match.times[i] >= 1e9 else 0) ts.setup(tau=args.tau, draw_probability=args.drawprob) players = extract_all_players(matches) ratings = {player: ts.Rating() for player in players} for match in matches: m_ratings = [{ match.players[i]: ratings[match.players[i]] } for i in range(len(match.players))] ranks = [0] * len(match.players) for i in range(1, len(match.players)): if match.times[i] == match.times[i - 1]: ranks[i] = ranks[i - 1] elif match.times[i] > match.times[i - 1]: ranks[i] = ranks[i - 1] + 1 new_ratings = ts.rate(m_ratings, ranks=ranks) new_ratings = {k: v for d in new_ratings for k, v in d.items()} for player, new_rating in new_ratings.items(): ratings[player] = new_rating players = sorted( players, key=lambda p: ratings[p].mu - args.sigmaweight * ratings[p].sigma, reverse=True) if args.addheader: columns = ['Player', 'Rating', 'Mu', 'Sigma', '#Matches', '#Forfeits'] if args.addplace: columns.insert(0, 'Place') print(*columns, sep=args.delim) place = 1 for player in players: if matches_no[player] < args.minmatches: continue rating = ratings[player] row = [ player, round(rating.mu - args.sigmaweight * rating.sigma, 3), round(rating.mu, 3), round(rating.sigma, 3), matches_no[player], forfeits_no[player] ] if args.addplace: row.insert(0, place) place += 1 print(*row, sep=args.delim)
def doRating(dfResults): env = ts.TrueSkill() ts.setup(tau=0.2) columns = ['Name', 'mu_minus_3sigma', 'numRaces', 'Rating'] dfRatings = pd.DataFrame(columns=columns, index=dfResults.index) dfRatings = pd.merge(dfRatings, dfResults[['numRegattas', 'lastRegatta']], left_index=True, right_index=True, how='outer') dfRatings['numRaces'] = dfResults.count(axis=1) dfRatings['Rating'] = pd.Series(np.repeat( env.Rating(), len(dfRatings))).T.values.tolist() for raceCol in dfResults: if (raceCol != 'numRegattas') or (raceCol != 'lastRegatta'): competed = dfRatings.index.isin( dfResults.index[dfResults[raceCol].notnull()]) rating_group = list( zip(dfRatings['Rating'][competed].T.values.tolist())) ranking_for_rating_group = dfResults[raceCol][ competed].T.values.tolist() dfRatings.loc[competed, 'Rating'] = ts.rate(rating_group, ranks=ranking_for_rating_group) dfRatings = pd.DataFrame(dfRatings) #convert to dataframe dfRatings['mu_minus_3sigma'] = pd.Series(np.repeat( 0.0, len(dfRatings))) #calculate mu - 3 x sigma: MSFT convention for index, row in dfRatings.iterrows(): dfRatings.loc[dfRatings.index == index, 'mu_minus_3sigma'] = float( row['Rating'].mu) - 3 * float(row['Rating'].sigma) #competed in at least 5 races and 1 regatta and has competed in the last 12 months dfRatings = dfRatings[dfRatings['numRaces'] > 4] dfRatings = dfRatings[dfRatings['numRegattas'] > 1] dfRatings = dfRatings[ (datetime.datetime.now() - dfRatings['lastRegatta']) / np.timedelta64(1, 'D') < 365] dfRatings['Name'] = dfRatings.index dfRatings.index = dfRatings['mu_minus_3sigma'].rank( ascending=False).astype(int) #set index to ranking dfRatings.index.names = ['Rank'] return dfRatings.sort_values('mu_minus_3sigma', ascending=False)
def load_env() -> None: env = None try: with open(ENV_FILE, "r") as f: env = json.load(f) except FileNotFoundError: pass except json.JSONDecodeError: print(f"Failed to read '{ENV_FILE}'") finally: if env: trueskill.setup(mu=env["mu"], sigma=env["sigma"]) else: trueskill.setup(mu=DEFAULT_MU, sigma=DEFAULT_SIGMA)
def main(): parser = argparse.ArgumentParser(description='MadCars Bot Competition') parser.add_argument('-n', '--num-games', type=int, help='Total number of games', required=True) parser.add_argument('-d', '--model-dir', type=str, help='NN model root directory', required=True) parser.add_argument('-l', '--log-interval', type=int, help='Rating print interval', default=50) parser.add_argument('-c', '--cache-path', type=str, default='competition_cache.json', help='Ragings JSON cache') args = parser.parse_args() model_dir: str = args.model_dir num_games: int = args.num_games cache_path: str = args.cache_path log_interval: int = args.log_interval ts.setup(draw_probability=0.0001) loop = events.new_event_loop() events.set_event_loop(loop) clients = get_simple_bots() + get_nn_bots(model_dir) clients = load_ratings(cache_path, clients) games_played = 0 while games_played < num_games: games_played += log_interval ratings = run_competition(clients, log_interval) ratings = sorted(ratings, key=lambda t: -ts.expose(t[1])) save_ratings(cache_path, clients) print(f'-- RATINGS {games_played} --') for name, rating in ratings: print( f'{ts.expose(rating):4.1f} ({rating.mu:4.1f} +- {rating.sigma * 3:4.1f}): {name:<32}' )
def run_cv(mu, sigma): cv_data = [] fix_variance = True if fix_variance: opponents_for_games, game_outcomes, true_elliot_skill = sim_games( None, True) for sigma in [mu / 50, mu / 25, mu / 10, mu / 3]: for beta in [sigma / 1.5, sigma / 2, sigma / 5]: for tau in [sigma / 200, sigma / 100, sigma / 50]: env = setup(mu=mu, sigma=sigma, beta=beta, tau=tau, draw_probability=0) if not fix_variance: opponents_for_games, game_outcomes, true_elliot_skill = sim_games( env, False) skill_mean, skill_var = update_skill(env, opponents_for_games, game_outcomes) cv_data.append([ mu, sigma, beta, tau, relative_mse(np.array(true_elliot_skill), skill_mean), skill_mean, skill_var ]) cv_res = pd.DataFrame(columns=[ 'mu', 'sigma', 'beta', 'tau', 'RMSE', 'skill_mean', 'skill_var' ], data=cv_data) best_vals = cv_res.sort_values('RMSE').reset_index() best_vals[['mu', 'sigma', 'beta', 'tau', 'RMSE']].to_csv('cv_as_ts_Mar_19.csv', index=False) return best_vals, true_elliot_skill
def substituted_trueskill(*args, **kwargs): env = trueskill.global_env() params = [['mu', env.mu], ['sigma', env.sigma], ['beta', env.beta], ['tau', env.tau], ['draw_probability', env.draw_probability], ['backend', env.backend]] # merge settings with previous TrueSkill object for x, arg in enumerate(args): params[x][1] = arg params = dict(params) for kw, arg in kwargs.items(): params[kw] = arg try: # setup the environment yield trueskill.setup(**params) finally: # revert the environment trueskill.setup(env=env)
def win_probability_heroes(team1, team2, mmr_dict, env=trueskill.setup()): ratings1 = [] for hero in team1: r = env.Rating(mmr_dict[hero]["mu"], mmr_dict[hero]["sigma"]) ratings1.append(r) ratings2 = [] for hero in team2: r = env.Rating(mmr_dict[hero]["mu"], mmr_dict[hero]["sigma"]) ratings2.append(r) return win_probability(ratings1, ratings2, env)
def calculate_mmr(replays, env=trueskill.setup()): mmr_dict = {} print("Calculating mmr...") for index, replay in replays.iterrows(): game_time = replay["game_date"] patch = replay["game_version"] heroes = replay[["hero" + str(i) for i in range(1, 11)]] winner = replay["winner"] mmr_dict = rate_game(game_time, patch, heroes, winner, mmr_dict, env) return mmr_dict
def compute_true_skills(user): """ recalculate TrueSkills from the entire history of fights """ # True Skill parameters for Movie ratings # Details and reasoning can be found at: # https://www.evernote.com/Home.action#st=p&n=ea2365e1-fe1c-4f4c-97b6-18cf78431fa4 ts.setup(mu=3.0, sigma=1.0, beta=0.3, tau=0.005, draw_probability=0.05) # initiate TrueSkill dict seededTS = {} # initialize TrueSkill for each rated movie for score in Score.objects.filter(user=user).exclude(starRating=0): imdb_id = score.movie_imdb_id() starRating = score.starRating seededTS[imdb_id] = ts.Rating(mu=1.*starRating, sigma=0.5) # iterate over fightes (over time) and incrementally update # TrueSkill dict count = 0 for fight in sorted(Fight.objects.filter(user=user), key = lambda m: m.timestamp): update_true_skill(fight, seededTS) if count and count % 200 == 0: print >> sys.stderr, '%i fights processed.' % count count += 1 # record new ratings in the database count = 0 for score in Score.objects.filter(user=user): movie_id = score.movie_imdb_id() try: new_TS = seededTS[movie_id] except KeyError: # this movie was just saved in between starting the TrueSkill # calculations and recording the results. we'll get it in the # next round. continue update_score(user, movie_id, new_TS) count += 1 #log('--- a total of %i ratings recorded. ---' % (count)) return count
def rate_skill(names, results, metrics): from trueskill import Rating, rate, setup MU = 1000 setup(MU, MU / 3, MU * 5, MU / 5000) started = time.clock() ratings = {x : Rating() for x in names} for entry in results: adjusted = rate([(ratings[x[0]],) for x in entry], [(int(not x[1]),) for x in entry]) for index, rating in enumerate(adjusted): ratings[entry[index][0]] = rating[0] print("Completed rankings in", str(int(time.clock() - started)), "seconds") print("") descending = sorted(ratings.items(), key=lambda x:x[1], reverse=True) for index, (name, rating) in enumerate(descending): metrics[name]["Rank"] = index metrics[name]["Mu"] = "%.0f" % rating.mu metrics[name]["Sigma"] = "%.0f" % rating.sigma
def substituted_trueskill(*args, **kwargs): """Setup the global environment only within the context:: assert Rating().mu == 25 with substituted_trueskill(mu=0): assert Rating().mu == 0 """ env = trueskill.global_env() params = [['mu', env.mu], ['sigma', env.sigma], ['beta', env.beta], ['tau', env.tau], ['draw_probability', env.draw_probability], ['backend', env.backend]] # merge settings with previous TrueSkill object for x, arg in enumerate(args): params[x][1] = arg params = dict(params) for kw, arg in kwargs.items(): params[kw] = arg try: # setup the environment yield trueskill.setup(**params) finally: # revert the environment trueskill.setup(env=env)
def rate_team(self): trueskill.setup(draw_probability = self.draw_prob()) team_rating = dict(zip(self.teams, [trueskill.global_env().create_rating()] * len(self.teams))) for match in self.regular_matches: wteam = match[self.regular_titles.index('Wteam')] lteam = match[self.regular_titles.index('Lteam')] wscore = match[self.regular_titles.index('Wscore')] lscore = match[self.regular_titles.index('Lscore')] if wteam in team_rating and lteam in team_rating: if wscore < lscore: wteam, lteam = lteam, wteam wscore, lscore = lscore, wscore team_rating[wteam], team_rating[lteam] = trueskill.rate_1vs1(team_rating[wteam], \ team_rating[lteam], drawn = self.is_equal_score(wscore, lscore)) wscore -= self.victory_margin while wscore - lscore >= self.victory_margin: team_rating[wteam], team_rating[lteam] = trueskill.rate_1vs1(team_rating[wteam], \ team_rating[lteam], drawn = self.is_equal_score(wscore, lscore)) wscore -= self.victory_margin return team_rating
def calc_new_ranking(ranking, bots, result, tau): ts.setup(tau=tau, draw_probability=0.0001) ratings = [[ts.Rating(mu=ranking[bot]['mu'], sigma=ranking[bot]['sigma'])] for bot in bots] ratings_ffa = [[ ts.Rating(mu=ranking[bot]['mu_ffa'], sigma=ranking[bot]['sigma_ffa']) ] for bot in bots] ratings_1v1 = [[ ts.Rating(mu=ranking[bot]['mu_1v1'], sigma=ranking[bot]['sigma_1v1']) ] for bot in bots] ratings = ts.rate(ratings, ranks=result) if len(bots) == 2: ratings_1v1 = ts.rate(ratings_1v1, ranks=result) else: ratings_ffa = ts.rate(ratings_ffa, ranks=result) for i, bot in enumerate(bots): ranking[bot]['mu'] = ratings[i][0].mu ranking[bot]['sigma'] = ratings[i][0].sigma ranking[bot]['mu_ffa'] = ratings_ffa[i][0].mu ranking[bot]['sigma_ffa'] = ratings_ffa[i][0].sigma ranking[bot]['mu_1v1'] = ratings_1v1[i][0].mu ranking[bot]['sigma_1v1'] = ratings_1v1[i][0].sigma ranking[bot]['games'] += 1
def accuracy(replays, mmr_dict, env=trueskill.setup()): correct = 0 total = 0 for i, row in replays.iterrows(): team1 = row[TEAM0] team2 = row[TEAM1] wp = win_probability_heroes(team1, team2, mmr_dict, env) pred_win = 0 if wp > 0.5 else 1 if pred_win == row["winner"]: correct += 1 total += 1 return correct / total
def rating_env_setup(): """Sets up Rating Environment, an object from trueskill module. Args: None, but setup uses Global variables defined above. Returns: Global env created= """ global_env = setup(mu=MU, sigma=SIGMA, beta=BETA, tau=TAU, draw_probability=DRAW_PROBABILITY, backend=None ) return global_env
def rate_game(game_time, patch, heroes, winner, mmr_dict, env=trueskill.setup()): ratings = [] for hero in heroes: if hero in mmr_dict: mu = mmr_dict[hero]["mu"] if patch not in mmr_dict[hero]["history"]["patches"]: sigma = env.sigma else: sigma = mmr_dict[hero]["sigma"] r = env.Rating(mu=mu, sigma=sigma) else: r = env.Rating() ratings.append(r) team1 = dict(zip(heroes[:5], ratings[:5])) team2 = dict(zip(heroes[5:], ratings[5:])) rankings = [1, 1] rankings[winner] = 0 rated_groups = env.rate([team1, team2], rankings) for hero in team1: new_r = rated_groups[0][hero] mmr_dict = update_mmr_dict(hero, game_time, patch, new_r.mu, new_r.sigma, rankings[0], mmr_dict) for hero in team2: new_r = rated_groups[1][hero] mmr_dict = update_mmr_dict(hero, game_time, patch, new_r.mu, new_r.sigma, rankings[0], mmr_dict) return mmr_dict
from .decorators import with_logger # Logging setup TRACE = 5 logging.addLevelName(TRACE, "TRACE") logging.getLogger("aiomeasures").setLevel(logging.INFO) logging.getLogger("aio_pika").setLevel(logging.INFO) # Constants FFA_TEAM = 1 # Credit to Axle for parameter changes, # see: http://forums.faforever.com/viewtopic.php?f=45&t=11698#p119599 # Optimum values for ladder here, using them for global as well. trueskill.setup(mu=1500, sigma=500, beta=240, tau=10, draw_probability=0.10) @with_logger class ConfigurationStore: def __init__(self): """ Change default values here. """ self.CONFIGURATION_REFRESH_TIME = 300 self.LOG_LEVEL = "DEBUG" self.PROFILING_COUNT = 300 self.PROFILING_DURATION = 2 self.PROFILING_INTERVAL = -1 self.CONTROL_SERVER_PORT = 4000
totalNumberGames = len(df) stripesWin = 0.0 breakWins = 0.0 df['gameID'] = range(1, len(df) + 1) df.set_index('gameID', inplace=True) df = fix_initials(df, 'RAL', 'RL') df = fix_initials(df, 'REL', 'RL') df = fix_initials(df, 'NS', 'NAS') p1 = df['Player1'].unique() p2 = df['Player2'].unique() playerList = np.unique(np.concatenate((p1, p2))) ts.setup(mu=ELOMEAN, sigma=(ELOMEAN / 3)**2, draw_probability=0.00) rankings = {p: ts.Rating() for p in playerList} trends = {p: [] for p in playerList} for g in range(len(df)): won = df.Winner[g + 1] if df.Player1[g + 1] == won: lost = df.Player2[g + 1] winner = rankings[won] loser = rankings[lost] newP1, newP2 = ts.rate_1vs1(winner, loser) rankings[won] = newP1 rankings[lost] = newP2 if df.Stripes[g + 1] == won: stripesWin = stripesWin + 1.0 breakWins = breakWins + 1.0
def fight_result(request, movie_1_id, movie_2_id, lock): if not request.user.is_authenticated(): args = (movie_1_id, movie_2_id, lock) return redirect_to_login('fight_result', args=args) # get the movies movie1 = get_object_or_404(Movie, pk=movie_1_id) movie2 = get_object_or_404(Movie, pk=movie_2_id) # get the user user = request.user # get the posted result result = request.POST['result'] # a result of -1 means "skip", no recording # in that case. Only record a valid result if int(result) in (0,1,2): # # ~~~~Design choice~~~~~~~~~~~~~ # When two movies that were previously compared are compared again, # we will not treat is as another match. Instead of multiple matches, # we will have a single result for any given pair. This is to allow # changes in opinion to have a more immediate effect, to remove # any confusion as to preferences between any two movies, and to keep # the database compact, simple and straightforward. # # Temporarily, score will be changed by a single update (as if # there have been multiple matches), but this will be corrected when # The main way of calculating TrueSkill is going over the entire chain # of Fights from scratch. # ~~~~~~~~~~~~~~~~ # # find the fight if these two movies were compared before # or create a new fight try: fight = Fight.objects.filter( user=user ).filter( contestants=movie1 ).filter( contestants=movie2 ).get() # make sure the movies are in the right order # so that the result integer is accurate fight.movie1, fight.movie2 = movie1, movie2 except Fight.DoesNotExist: # match not in database, create a new match fight = Fight(user=user, movie1=movie1, movie2=movie2) # record the result fight.result = result # record the date and time (this is not necessary if a new match # is created, since this is done by default, but it is necessary # if an old match is retrieved. fight.timestamp = now() # put the match in the database fight.save() # --end of recording (end of if) # update scores (until periodic cleaner recalculation) # set parameters ts.setup(mu=3.0, sigma=1.0, beta=0.3, tau=0.005, draw_probability=0.05) # retrieve scores to update score1 = Score.objects.get(user=user, movie=movie1) score2 = Score.objects.get(user=user, movie=movie2) # create VS score objects old_VS_1 = ts.Rating(mu=score1.mu, sigma=score1.sigma) old_VS_2 = ts.Rating(mu=score2.mu, sigma=score2.sigma) # update: get the new VS score objects if int(result) == 0: new_VS_1, new_VS_2 = ts.rate_1vs1(old_VS_1, old_VS_2, drawn=True) elif int(result) == 1: new_VS_1, new_VS_2 = ts.rate_1vs1(old_VS_1, old_VS_2, drawn=False) elif int(result) == 2: new_VS_2, new_VS_1 = ts.rate_1vs1(old_VS_2, old_VS_1, drawn=False) else: new_VS_1, new_VS_2 = None, None # save new scores to the db if new_VS_1: update_score(user, movie1, new_VS_1) if new_VS_2: update_score(user, movie2, new_VS_2) # scores are updated # pick new movies to fight and redirect to the fight new_fighters = {} if lock == '1': new_fighters['movie_1_id'] = movie_1_id name = 'fight_a' elif lock == '2': new_fighters['movie_2_id'] = movie_2_id name = 'fight_b' else: name = 'fight' return HttpResponseRedirect(reverse(name, kwargs=new_fighters))
import trueskill from trueskill import TrueSkill, Rating from flask import Flask, request, jsonify from flask_swagger import swagger # global FLASK setup app = Flask(__name__, static_url_path='') app.config['DEBUG'] = True # global TRUESKILL setup trueskill.setup(backend='mpmath') # Note: We don't need to call run() since our application is embedded within # the App Engine WSGI application server. class InvalidAPIUsage(Exception): status_code = 400 def __init__(self, message, status_code=None, payload=None): Exception.__init__(self) self.message = message if status_code is not None: self.status_code = status_code self.payload = payload def to_dict(self): rv = dict(self.payload or ()) rv['message'] = self.message return rv
def save_result(request): #Neues Ergebnis eintragen #Muss noch Fehlerabfrage einbauen (nur positive Zahlen und kein Draw erlaubt) g = Game.objects.get(id=request.POST['game']) g.goals_1 = request.POST['goals_1'] g.goals_2 = request.POST['goals_2'] g.save() if g.goals_1 > g.goals_2: foo=1 else: foo=0 result=[1-foo,foo] #Globalen TrueSkill berechnen setup(beta=666, draw_probability=0) off1 = Rating(mu=g.off_player1.mu,sigma=g.off_player1.sigma) def1 = Rating(mu=g.def_player1.mu,sigma=g.def_player1.sigma) off2 = Rating(mu=g.off_player2.mu,sigma=g.off_player2.sigma) def2 = Rating(mu=g.def_player2.mu,sigma=g.def_player2.sigma) team1 = [off1,def1] team2 = [off2,def2] (new_off1,new_def1),(new_off2,new_def2)=rate([team1,team2],result) g.off_player1.mu = new_off1.mu g.off_player1.sigma = new_off1.sigma g.off_player1.save() g.off_player2.mu = new_off2.mu g.off_player2.sigma = new_off2.sigma g.off_player2.save() g.def_player1.mu = new_def1.mu g.def_player1.sigma = new_def1.sigma g.def_player1.save() g.def_player2.mu = new_def2.mu g.def_player2.sigma = new_def2.sigma g.def_player2.save() #Positionsskill berechnen off1 = Rating(mu=g.off_player1.mu_off,sigma=g.off_player1.sigma_off) def1 = Rating(mu=g.def_player1.mu_def,sigma=g.def_player1.sigma_def) off2 = Rating(mu=g.off_player2.mu_off,sigma=g.off_player2.sigma_off) def2 = Rating(mu=g.def_player2.mu_def,sigma=g.def_player2.sigma_def) team1 = [off1,def1] team2 = [off2,def2] (new_off1,new_def1),(new_off2,new_def2)=rate([team1,team2],result) g.off_player1.mu_off = new_off1.mu g.off_player1.sigma_off = new_off1.sigma g.off_player1.save() g.off_player2.mu_off = new_off2.mu g.off_player2.sigma_off = new_off2.sigma g.off_player2.save() g.def_player1.mu_def = new_def1.mu g.def_player1.sigma_def = new_def1.sigma g.def_player1.save() g.def_player2.mu_def = new_def2.mu g.def_player2.sigma_def = new_def2.sigma g.def_player2.save() archiv=Archiv(game=g,player=g.off_player1,mu=g.off_player1.mu,sigma=g.off_player1.sigma,mu_off=g.off_player1.mu_off,sigma_off=g.off_player1.sigma_off,mu_def=g.off_player1.mu_def,sigma_def=g.off_player1.sigma_def) archiv.save() archiv=Archiv(game=g,player=g.def_player1,mu=g.def_player1.mu,sigma=g.def_player1.sigma,mu_off=g.def_player1.mu_off,sigma_off=g.def_player1.sigma_off,mu_def=g.def_player1.mu_def,sigma_def=g.def_player1.sigma_def) archiv.save() archiv=Archiv(game=g,player=g.off_player2,mu=g.off_player2.mu,sigma=g.off_player2.sigma,mu_off=g.off_player2.mu_off,sigma_off=g.off_player2.sigma_off,mu_def=g.off_player2.mu_def,sigma_def=g.off_player2.sigma_def) archiv.save() archiv=Archiv(game=g,player=g.def_player2,mu=g.def_player2.mu,sigma=g.def_player2.sigma,mu_off=g.def_player2.mu_off,sigma_off=g.def_player2.sigma_off,mu_def=g.def_player2.mu_def,sigma_def=g.def_player2.sigma_def) archiv.save() return HttpResponseRedirect(reverse('kicker_app:open_games'))
board_size = int(config["GLOBAL"]["board_size"]) log_dir = config["GLOBAL"]["log_dir"] out_dir = config["expertEval"]["dir"] out_dir = out_dir.format(board_size=board_size) base_dir = "/".join([log_dir, out_dir]) os.makedirs(base_dir, exist_ok=True) exit_dir = config["ExpertIteration"]["dir"] exit_dir = exit_dir.format(board_size=board_size) step_location = config["ExpertIteration"]["step_location"] agent_template = "/".join([log_dir, exit_dir, step_location, "model.h5"]) trueskill.setup(mu=float(config["TrueSkill"]["initial_mu"]), sigma=float(config["TrueSkill"]["initial_sigma"]), beta=float(config["TrueSkill"]["beta"]), tau=float(config["TrueSkill"]["tau"]), draw_probability=float( config["TrueSkill"]["draw_probability"]), backend="scipy") num_threads = int(config["GLOBAL"]["num_threads"]) iterations = int(config["ExpertIteration"]["iterations"]) board_size = int(config["GLOBAL"]["board_size"]) model_file = config["expertEval"]["model_file"] nn_agent = NNAgent(model_file) depths = [ 0, 50, 100, 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000 ] num_matches = int(config["GLOBAL"]["num_matches"])
'games': 0 } for (team, nGames) in games.groupby('t1').size().iteritems(): teams[team]['games'] += nGames for (team, nGames) in games.groupby('t2').size().iteritems(): teams[team]['games'] += nGames for ((team, result), nGames) in games.groupby(['t1', 'result']).size().iteritems(): teams[team]['wins'] += nGames if result == 1 else 0 teams[team]['losses'] += nGames if result == 0 else 0 for ((team, result), nGames) in games.groupby(['t2', 'result']).size().iteritems(): teams[team]['wins'] += nGames if result == 0 else 0 teams[team]['losses'] += nGames if result == 1 else 0 return teams ts.setup(mu=1500, sigma=300, beta=200, draw_probability=0) def trueskillExpectedWinRate(r1, r2, blueSide=0): deltaMu = r1.mu - r2.mu + blueSide sumSigma = r1.sigma ** 2 + r2.sigma ** 2 denominator = math.sqrt(4 * (200 * 200) + sumSigma) return ts.global_env().cdf(deltaMu / denominator) def g(variance): return 1 / math.sqrt(1 + 3 * math.pow(math.log(10) / 400 / math.pi, 2) * variance) def glickoExpectedWinRate(r1, r2, blueSide=0): return 1 / (1 + math.pow(10, g(r1.getRd() * r1.getRd() + r2.getRd() * r2.getRd()) * (r2.getRating() - r1.getRating() - blueSide) / 400))
from . import version import os import logging import trueskill from PyQt4 import QtCore from logging.handlers import RotatingFileHandler, MemoryHandler trueskill.setup(mu=1500, sigma=500, beta=250, tau=5, draw_probability=0.10) _settings = QtCore.QSettings(QtCore.QSettings.IniFormat, QtCore.QSettings.UserScope, "ForgedAllianceForever", "FA Lobby") _unpersisted_settings = {} class Settings: """ This wraps QSettings, fetching default values from the selected configuration module if the key isn't found. """ @staticmethod def get(key, default=None, type=str): # Get from a local dict cache before hitting QSettings # this is for properties such as client.login which we # don't necessarily want to persist if key in _unpersisted_settings: return _unpersisted_settings[key] # Hit QSettings to see if the user has defined a value for the key if _settings.contains(key): return _settings.value(key, type=type) # Try out our defaults for the current environment return defaults.get(key, default)
from mako.template import Template import mechanize import os import re import trueskill CACHE = 'cache' DATE_STR = '%Y-%m-%d' parser = argparse.ArgumentParser(description='Create Elo rankings from Challonge brackets') parser.add_argument('--cache', action='store_true', help="Don't fetch from web, just use results in cache") parser.add_argument('--html', action='store_true', help='Output to html page') parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output') args = parser.parse_args() trueskill.setup(draw_probability=0) if args.verbose: logging.basicConfig(level=logging.INFO) class Player: def title(self, name): if len(name) == 1: return name[0].upper() else: return name[0].upper() + name[1:] def clean_up(self, name): name = name.lower() # remove the ones that include the classes or #number
STATIC_ROOT = os.path.join(ABSOLUTE_BASE, 'static2') # General settings SUPPORTED_YEARS = list(range(2010, 2018)) LEADERBOARD_COUNT = 200 # For Elo/Trueskill system import trueskill DEFAULT_MU = elo.MU.value DEFAULT_SIGMA = elo.SIGMA.value DEFAULT_BETA = elo.BETA.value DEFAULT_TAU = elo.TAU.value DEFAULT_DRAW_PROBABILITY = elo.DRAW_PROBABILITY.value ELO_DECAY_ALPHA = elo.DECAY_ALPHA.value trueskill.setup(mu=DEFAULT_MU, sigma=DEFAULT_SIGMA, beta=DEFAULT_BETA, tau=DEFAULT_TAU, draw_probability=DEFAULT_DRAW_PROBABILITY, backend="mpmath") # For model visualization at /plate/ SPAGHETTI_SAUCE = { 'apps': ['TBAW'], 'show_fields': False, 'exclude': {'auth': ['user']} } # NPlusOne Logging LOGGING_DIR = base.LOGGING_DIR.value LOGGING = { 'version': 1, 'handlers': { 'console': { 'level': 'DEBUG',
def main(): mpmath.mp.dps = 1000 start_time = time.time() years = range(1985,2015) #these parameters values were not varied during optimization #initial values for (AP) ranked and unranked teams ratedFactor = 30 unratedMu = 1 unratedSigma = 10 ratedSigma = 10 beta = 4 tau = 0.6 unratedRating = 5000 #only used for validation against other metrics #these parameters were optimized using a truncated Newton algorithm to search #8 years were optimized, and each year's values were cross-validated with all other years newseasonSigma = 32.038469 continuingSigma = 0.0001 hometau = 0.0982 awaytau = 0.54607 diffclose = 9.262603 diffblowout = 10.538232 cols = ['season','Week','Team','RatingMu','RatingSigma','Rating'] ratingsTable = pd.DataFrame(columns = cols) ts.setup(mu=unratedMu,sigma=unratedSigma,beta=beta,tau=tau) #connect to SQL login = pd.read_pickle('credentials.pkl') username = login.usernames.ix[0] password = login.passwords.ix[0] con = mdb.connect(host='localhost',user=username,passwd=password,db='NCAA',unix_socket="/tmp/mysql.sock") #create lists that can hold Rating values ratings = [] ratings.append([]) ratings.append([]) #season DataFrames seasonTeams = pd.read_sql_query('select team from games where season = ' + str(years[0]) + ' group by team',con) initialSeasonRankings = pd.read_sql_query('select Team, APrank from rankings where Year = ' + str(years[0]) + ' and Week = 0',con) #initialize preseason values for team in seasonTeams: ratings[0].append(team) try: initialRank = initialSeasonRankings[initialSeasonRankings.Team == team].APrank.values teamRating = ts.Rating(mu=(ratedFactor/int(initialRank)), sigma = ratedSigma) except (ValueError, TypeError): teamRating = ts.Rating() ratings[1].append(teamRating) del initialSeasonRankings del seasonTeams def run_season(year,ratings, ratingsTable): #initialize parameters year = [year] for year in year: year = str(year) year_start_time = time.time() #season DataFrames seasonGames = pd.read_sql_query('select Team, Wk from games where season = ' + year,con) #initializing values for team in seasonGames.Team.unique(): try: teamindex = ratings[0].index(team) ratings[1][teamindex] = ts.Rating(mu=ratings[1][teamindex].mu,sigma=newseasonSigma) except ValueError: ratings[0].append(team) teamRating = ts.Rating() ratings[1].append(teamRating) for week in seasonGames.Wk.unique(): #initialize week week_start_time = time.time() print 'week ' + str(week) week = str(week) weekGames = pd.read_sql_query('select winner, loser, winnerPts, loserPts from games where Wk = ' + week + ' and season = ' + year,con) weekGames = weekGames.dropna() for game in weekGames.winner.unique(): #getting values winnerIndex = ratings[0].index(game) loserteam = weekGames[weekGames.winner == game].iloc[0].loser loserIndex = ratings[0].index(weekGames[weekGames.winner == game].iloc[0].loser) winnerRating = ratings[1][winnerIndex] loserRating = ratings[1][loserIndex] #get location location = pd.read_sql_query('select location from games where season = ' + str(year) + ' and Wk = ' + str(week) + ' and winner = \'' + str(game) + '\'',con).values[0] #get points differential winnerPts = weekGames[(weekGames.winner == game) & (weekGames.winnerPts != None)].winnerPts.unique()[0] loserPts = weekGames[(weekGames.winner == game) & (weekGames.loserPts != None)].loserPts.unique()[0] differential = int(winnerPts) - int(loserPts) if differential < 3: differential = 1 elif differential < 14: differential = diffclose else: differential = diffblowout #playing the game winnerRating = ts.Rating(mu=winnerRating.mu,sigma=continuingSigma*winnerRating.sigma) loserRating = ts.Rating(mu=loserRating.mu,sigma=continuingSigma*loserRating.sigma) if location == game: env = ts.TrueSkill(tau=hometau*differential, backend='mpmath') elif location == loserteam: env = ts.TrueSkill(tau=awaytau*differential, backend='mpmath') else: env = ts.TrueSkill(backend='mpmath') winnerRating, loserRating = ts.rate_1vs1(winnerRating, loserRating, env=env) del location del env ratings[1][winnerIndex] = winnerRating ratings[1][loserIndex] = loserRating #saving ranking information' ratingsmu = [] ratingssigma = [] TSrating = [] for i in range(len(ratings[0])): ratingsmu.append(ratings[1][i].mu) ratingssigma.append(ratings[1][i].sigma) TSrating.append(ratings[1][i].mu - 3*ratings[1][i].sigma) data = {'season': year, 'Week': week, 'Team': ratings[0], 'RatingMu': ratingsmu, 'RatingSigma': ratingssigma, 'Rating': TSrating} teamRatings = pd.DataFrame(data) #,index=[1]) teamRatings['Rank'] = len(teamRatings.index)-np.argsort(teamRatings.sort(['Rating'],ascending=False),axis=0).Rating ratingsTable = ratingsTable.append(teamRatings,ignore_index=True) del teamRatings print time.time() - week_start_time print time.time() - year_start_time return ratings, ratingsTable for year in years: print 'running year ' + str(year) ratings, ratingsTable = run_season(year,ratings,ratingsTable) #saving results ratingsTable.to_pickle('ratingsTable_final.pkl') print (time.time() - start_time)
def main(): mpmath.mp.dps = 1000 start_time = time.time() seasonYear = datetime.now().year weeks = [1,2,3,4,5,6] week = 6 seasonYear = 2013 iterations = 10 years = [] for i in range(iterations): years.append(seasonYear) #these parameters values were not varied during optimization #initial values for (AP) ranked and unranked teams ratedFactor = 30 unratedMu = 1 unratedSigma = 10 ratedSigma = 10 beta = 4 tau = 0.6 unratedRating = 5000 #only used for validation against other metrics #these parameters were optimized using a truncated Newton algorithm to search #8 years were optimized, and each year's values were cross-validated with all other years newseasonSigma = 32.038469 continuingSigma = 0.0001 hometau = 0.0982 awaytau = 0.54607 diffclose = 9.262603 diffblowout = 10.538232 ts.setup(mu=unratedMu,sigma=unratedSigma,beta=beta,tau=tau) #connect to SQL login = pd.read_pickle('credentials.pkl') username = login.usernames.ix[0] password = login.passwords.ix[0] con = mdb.connect(host='localhost',user=username,passwd=password,db='NCAA',unix_socket="/tmp/mysql.sock") #create lists that can hold Rating values ratings = [] ratings.append([]) ratings.append([]) #season DataFrames seasonTeams = pd.read_sql_query('select team from currentgames where season = ' + str(year) + ' group by team',con) initialSeasonRankings = pd.read_sql_query('select Team, APrank from rankings where Year = ' + str(year) + ' and Week = 0',con) #initialize preseason values for team in seasonTeams.team.unique(): ratings[0].append(team) try: initialRatings = pd.read_sql_query('select RatingMu, RatingSigma from finalratings where Team = \'' + team + '\' and season = \'' + str(year) + '\' and Week = \'' + str(int(week)-1) + '\'',con).ix[0] ratings[1].append(ts.Rating(mu=initialRatings[0],sigma=initialRatings[1])) except (ValueError, TypeError): teamRating = ts.Rating() ratings[1].append(teamRating) del initialSeasonRankings del seasonTeams def run_season(year,ratings): #initialize parameters year = [year] for year in year: year = str(year) year_start_time = time.time() #season DataFrames seasonGames = pd.read_sql_query('select Team, Wk from currentgames where season = ' + year,con) #initializing values for team in seasonGames.Team.unique(): try: teamindex = ratings[0].index(team) ratings[1][teamindex] = ts.Rating(mu=ratings[1][teamindex].mu,sigma=newseasonSigma) except ValueError: ratings[0].append(team) teamRating = ts.Rating() ratings[1].append(teamRating) for week in range(1,6): #initialize week week_start_time = time.time() print 'week ' + str(week) week = str(week) weekGames = pd.read_sql_query('select winner, loser, winnerPts, loserPts from currentgames where Wk = ' + week + ' and season = ' + year,con) weekGames = weekGames.dropna() weekGames = weekGames[weekGames.winnerPts != 'None'] for game in weekGames.winner.unique(): #getting values winnerIndex = ratings[0].index(game) loserteam = weekGames[weekGames.winner == game].iloc[0].loser loserIndex = ratings[0].index(weekGames[weekGames.winner == game].iloc[0].loser) winnerRating = ratings[1][winnerIndex] loserRating = ratings[1][loserIndex] #get location location = pd.read_sql_query('select location from currentgames where season = ' + str(year) + ' and Wk = ' + str(week) + ' and winner = \'' + str(game) + '\'',con).values[0] #get points differential winnerPts = weekGames[(weekGames.winner == game) & (weekGames.winnerPts != None)].winnerPts.unique()[0] loserPts = weekGames[(weekGames.winner == game) & (weekGames.loserPts != None)].loserPts.unique()[0] differential = int(winnerPts) - int(loserPts) if differential < 3: differential = 1 elif differential < 14: differential = diffclose else: differential = diffblowout #playing the game winnerRating = ts.Rating(mu=winnerRating.mu,sigma=continuingSigma*winnerRating.sigma) loserRating = ts.Rating(mu=loserRating.mu,sigma=continuingSigma*loserRating.sigma) if location == game: env = ts.TrueSkill(tau=hometau*differential, backend='mpmath') elif location == loserteam: env = ts.TrueSkill(tau=awaytau*differential, backend='mpmath') else: env = ts.TrueSkill(backend='mpmath') winnerRating, loserRating = ts.rate_1vs1(winnerRating, loserRating, env=env) del location del env ratings[1][winnerIndex] = winnerRating ratings[1][loserIndex] = loserRating print time.time() - week_start_time print time.time() - year_start_time return ratings for year in years: print 'running year ' + str(year) ratings = run_season(year,ratings) ratingsmu = [] ratingssigma = [] TSrating = [] for i in range(len(ratings[0])): ratingsmu.append(ratings[1][i].mu) ratingssigma.append(ratings[1][i].sigma) TSrating.append(ratings[1][i].mu - 3*ratings[1][i].sigma) data = {'season': str(year), 'Week': str(week), 'Team': ratings[0], 'RatingMu': ratingsmu, 'RatingSigma': ratingssigma, 'Rating': TSrating} teamRatings = pd.DataFrame(data) #,index=[1]) D1A = pd.read_pickle('D1A.pkl') teamRatings = teamRatings[teamRatings.Team.isin(list(D1A.team))] teamRatings['Rank'] = len(teamRatings.index)-np.argsort(teamRatings.sort(['Rating'],ascending=False),axis=0).Rating ratingsTable = teamRatings.copy() oldRatingsTable = pd.read_pickle('ratingsTable_final3.pkl') newRatingsTable = oldRatingsTable.merge(ratingsTable,how='outer') print newRatingsTable[(newRatingsTable.Team == 'Michigan') & (newRatingsTable.Week == str(week)) & (newRatingsTable.season == str(year))] #saving results newRatingsTable.to_pickle('ratingsTable_final6.pkl') newratingsTable.to_sql(con=con, name='finalratings6',if_exists='replace',flavor='mysql') print (time.time() - start_time)
parser.add_argument("--end-date", action="store", dest="end_date", default=datetime.now().isoformat().split("T")[0], help="Scrape end date in yyyy-mm-dd") args = parser.parse_args() conn = sqlite3.connect(args.db, timeout=10) c = conn.cursor() end_date = datetime.strptime(args.end_date, '%Y-%m-%d') if args.begin_date != None: begin_date = datetime.strptime(args.begin_date, '%Y-%m-%d') elif args.scrape_lookback != None: begin_date = datetime.now() - timedelta(days=int(args.scrape_lookback)) trueskill.setup(draw_probability=0.0018469) FENCER_STATE = dict() def updateRank(bout): def getLatestRating(fencerid, weapon): if (fencerid, weapon) in FENCER_STATE: return FENCER_STATE[(fencerid, weapon)] query = c.execute(""" SELECT r.ts_mu, r.ts_sigma FROM ratings r , bouts b, events e, tournaments t WHERE r.fencerid = %(fencerid)s AND r.boutid = b.boutid AND e.weapon = '%(weapon)s' AND b.eventid = e.eventid AND e.tournamentid = t.tournamentid AND t.start_date < '%(begin_date)s'
def calculate_score_1vs1(self, key1_scored_object, key2_scored_object, winning_key, other_comparison_pairs): """ Calcualtes 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 winning_key: indicates with key is the winning key :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 = {} self.ratings = {} trueskill.setup() key1 = key1_scored_object.key key2 = key2_scored_object.key # Note: if value are None, trueskill.Rating will use default mu 25 and sigma 8.333 r1 = trueskill.Rating(mu=key1_scored_object.variable1, sigma=key1_scored_object.variable2) r2 = trueskill.Rating(mu=key2_scored_object.variable1, sigma=key2_scored_object.variable2) if winning_key == key1: r1, r2 = trueskill.rate_1vs1(r1, r2) elif winning_key == key2: r2, r1 = trueskill.rate_1vs1(r2, r1) else: raise InvalidWinningKeyException self.ratings[key1] = r1 self.ratings[key2] = r2 for key in [key1, key2]: self.opponents[key] = set() self.storage[key] = ScoredObject( key=key, score=trueskill.expose(self.ratings[key]), variable1=self.ratings[key].mu, variable2=self.ratings[key].sigma, 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, winning_key)]: cp_key1 = comparison_pair.key1 cp_key2 = comparison_pair.key2 cp_winning_key = comparison_pair.winning_key if cp_key1 == key1 or cp_key1 == key2: if cp_winning_key is None: self._update_rounds_only(cp_key1) else: self._update_result_stats(cp_key1, cp_key2, cp_winning_key) if cp_key2 == key1 or cp_key2 == key2: if cp_winning_key is None: self._update_rounds_only(cp_key2) else: self._update_result_stats(cp_key2, cp_key1, cp_winning_key) return (self.storage[key1], self.storage[key2])
from database.SessionFactory import SessionFactory from database.User import User from database.Match import Match from database.Game import Game from database.Score import Score from database.Participation import Participation from database.TrueSkillCache import TrueSkillCache import trueskill import time from resultdict import resultdict trueskill.setup() def get_most_recent_ratings(user_id): from sqlalchemy.orm.exc import NoResultFound session = SessionFactory() try: participation_matches = session.query( Match.id.label("match_id"), Match.date_recorded.label("date") ).\ filter( Participation.user_id == user_id ).\ filter( Participation.match_id == Match.id ).subquery() most_recent_match_date = session.query( participation_matches.c.match_id.label("match_id"), func.max(participation_matches.c.date).label("date") ).\ subquery() most_recent_match = session.query( participation_matches.c.match_id.label("match_id") ).\