Spaces:
Sleeping
Sleeping
| import numpy as np | |
| import pandas as pd | |
| from stqdm import stqdm | |
| from typing import List, Mapping, MutableMapping, Tuple | |
| def simulate_game(team_name: str, mean_points: float, std_points: float) -> float: | |
| general_normal = np.round(np.random.normal(mean_points, std_points), 3) | |
| return general_normal | |
| def simulate_week_matchups(df_week: pd.DataFrame, mean_points: float, std_points: float) -> pd.DataFrame: | |
| df_week.loc[:, "team_points"] = df_week.team_name.apply(lambda x: simulate_game(x, mean_points, std_points)).values | |
| df_week.loc[:, "max_match"] = df_week.groupby("match_index").team_points.transform("max").values | |
| df_week.loc[:, "win_probability"] = ((df_week["team_points"] == df_week["max_match"]) * 1.0).values | |
| df_week.drop(columns=["max_match"], inplace=True) | |
| return df_week | |
| def simulate_remaining_season(df_completed_weeks: pd.DataFrame, df_incomplete_weeks: pd.DataFrame) -> pd.DataFrame: | |
| df_comp = df_completed_weeks.copy() | |
| df_inc = df_incomplete_weeks.copy() | |
| mean_points = df_comp.team_points.mean() | |
| std_points = df_comp.team_points.std() | |
| sim_week_list = [ | |
| simulate_week_matchups(df_week, mean_points, std_points) for (_, df_week) in df_inc.groupby("week") | |
| ] | |
| df_full_sim = pd.concat([df_comp] + sim_week_list) | |
| return df_full_sim | |
| def summarize_season(df_sim: pd.DataFrame, n_bye: int, n_playoff: int) -> pd.DataFrame: | |
| sim_sum = ( | |
| df_sim.groupby("team_name")[["win_probability", "team_points"]] | |
| .sum() | |
| .sort_values(["win_probability", "team_points"], ascending=False) | |
| ) | |
| sim_sum["season_rank"] = range(1, 1 + len(sim_sum)) | |
| sim_sum["bye"] = (sim_sum["season_rank"] <= n_bye) * 1 | |
| sim_sum["playoff"] = (sim_sum["season_rank"] <= n_playoff) * 1 | |
| return sim_sum | |
| def finalize_all(df: pd.DataFrame) -> None: | |
| df["win_probability"] = (df.groupby(["week", "match_index"]).team_points.transform("max") == df.team_points) * 1 | |
| def run_simulations(df: pd.DataFrame, complete_weeks: int, n_sims: int, n_playoff: int): | |
| if n_playoff == 6: | |
| n_bye = 2 | |
| else: | |
| n_bye = 0 | |
| df_comp = df[df.week <= complete_weeks] | |
| finalize_all(df_comp) | |
| df_inc = df[df.week > complete_weeks] | |
| sim_list = [] | |
| for i in stqdm(range(n_sims)): | |
| df_sim = simulate_remaining_season(df_comp, df_inc) | |
| sim_sum = summarize_season(df_sim, n_bye, n_playoff) | |
| df_simmed = df_sim[df_sim.week > complete_weeks] | |
| win_dict = { | |
| match_key: df_match.sort_values("team_points").team_name.iloc[-1] | |
| for (match_key, df_match) in df_simmed.groupby(["week", "match_index"]) | |
| } | |
| df_wins = pd.DataFrame(win_dict, index=[i]) | |
| df_melt = ( | |
| sim_sum.reset_index()[["team_name", "bye", "playoff", "season_rank", "team_points"]] | |
| .melt(id_vars="team_name") | |
| .sort_values(["variable", "team_name"]) | |
| ) | |
| df_team_sum = pd.DataFrame( | |
| {x[0]: x[1] for x in df_melt.apply(lambda r: [(r.variable, r.team_name), r.value], axis=1).values}, | |
| index=[i], | |
| ) | |
| df_sim_result = df_team_sum.join(df_wins) | |
| sim_list.append(df_sim_result) | |
| df_all_sims = pd.concat(sim_list) | |
| return df_all_sims | |
| def create_simulate_summary(sims: pd.DataFrame) -> pd.DataFrame: | |
| df_sim_sum = pd.DataFrame() | |
| df_sim_sum["bye"] = sims.bye.mean() | |
| df_sim_sum["playoffs"] = sims.playoff.mean() | |
| return ( | |
| df_sim_sum[["bye", "playoffs"]] | |
| .sort_values(["playoffs", "bye"], ascending=False) | |
| .map(lambda n: "{:,.2%}".format(n)) | |
| ) | |
| def get_matches_by_team_from_sims_df(sims: pd.DataFrame) -> Mapping[str, List[Tuple[int]]]: | |
| team_matches: MutableMapping[str, List[Tuple[int]]] = {} | |
| for col in sims.columns: | |
| if isinstance(col[0], (int, float)): | |
| teams_in_match = sims[col].unique() | |
| for team in teams_in_match: | |
| if team in team_matches: | |
| team_matches[team].append(col) | |
| else: | |
| team_matches[team] = [col] | |
| return team_matches | |
| def calc_wins_on_scenario(team_name, match_cols_list, sims_df): | |
| n_matches = len(match_cols_list) | |
| scenario_bye_playoff_results = {} | |
| for i in range(2**n_matches): | |
| binary_scenario = format(i, f"0{n_matches}b") | |
| filters = [] | |
| for scenario, match in zip(binary_scenario, match_cols_list): | |
| match_filter = (sims_df[match] == team_name) == bool(int(scenario)) | |
| filters.append(match_filter) | |
| filtered_sims = sims_df[pd.DataFrame(filters).all()] | |
| playoff_odds = filtered_sims["playoff"][team_name].mean() | |
| bye_odds = filtered_sims["bye"][team_name].mean() | |
| scenario_bye_playoff_results[binary_scenario] = np.nan_to_num( | |
| [len(filtered_sims), round(playoff_odds, 3), round(bye_odds, 3)] | |
| ).tolist() | |
| return scenario_bye_playoff_results | |
| def calculate_scenario_probabilities(sims: pd.DataFrame) -> Mapping: | |
| remaining_matches = get_matches_by_team_from_sims_df(sims) | |
| team_scenario_probs = { | |
| team: calc_wins_on_scenario(team, matches, sims) for team, matches in remaining_matches.items() | |
| } | |
| return team_scenario_probs | |