Spaces:
Sleeping
Sleeping
import streamlit as st | |
import pandas as pd | |
import joblib | |
def main(): | |
st.title("FIFA winner predication") | |
st.write('This app predict 2022 FIFA winner') | |
if st.button("Predict FIFA Winner"): | |
last_team_scores = pd.read_csv('./data/last_team_scores.csv') | |
last_team_scores.tail() | |
squad_stats = pd.read_csv('./data/squad_stats.csv') | |
squad_stats.tail() | |
group_matches = pd.read_csv('./data/Qatar_group_stage.csv') | |
round_16 = group_matches.iloc[48:56, :] | |
quarter_finals = group_matches.iloc[56:60, :] | |
semi_finals = group_matches.iloc[60:62, :] | |
final = group_matches.iloc[62:63, :] | |
second_final = group_matches.iloc[63:64, :] | |
group_matches = group_matches.iloc[:48, :] | |
group_matches.tail() | |
xgb_gs_model = joblib.load("./groups_stage_prediction.pkl") | |
xgb_ks_model = joblib.load("./knockout_stage_prediction.pkl") | |
team_group = group_matches.drop(['country2'], axis=1) | |
team_group = team_group.drop_duplicates().reset_index(drop=True) | |
team_group = team_group.rename(columns={"country1": "team"}) | |
team_group.head(5) | |
def matches(g_matches): | |
g_matches.insert(2, 'potential1', | |
g_matches['country1'].map(squad_stats.set_index('nationality_name')['potential'])) | |
g_matches.insert(3, 'potential2', | |
g_matches['country2'].map(squad_stats.set_index('nationality_name')['potential'])) | |
g_matches.insert(4, 'rank1', g_matches['country1'].map(last_team_scores.set_index('team')['rank'])) | |
g_matches.insert(5, 'rank2', g_matches['country2'].map(last_team_scores.set_index('team')['rank'])) | |
pred_set = [] | |
for index, row in g_matches.iterrows(): | |
if row['potential1'] > row['potential2'] and abs(row['potential1'] - row['potential2']) > 2: | |
pred_set.append({'Team1': row['country1'], 'Team2': row['country2']}) | |
elif row['potential2'] > row['potential1'] and abs(row['potential2'] - row['potential1']) > 2: | |
pred_set.append({'Team1': row['country2'], 'Team2': row['country1']}) | |
else: | |
if row['rank1'] > row['rank2']: | |
pred_set.append({'Team1': row['country1'], 'Team2': row['country2']}) | |
else: | |
pred_set.append({'Team1': row['country2'], 'Team2': row['country1']}) | |
pred_set = pd.DataFrame(pred_set) | |
pred_set.insert(2, 'Team1_FIFA_RANK', pred_set['Team1'].map(last_team_scores.set_index('team')['rank'])) | |
pred_set.insert(3, 'Team2_FIFA_RANK', pred_set['Team2'].map(last_team_scores.set_index('team')['rank'])) | |
pred_set.insert(4, 'Team1_Goalkeeper_Score', | |
pred_set['Team1'].map(last_team_scores.set_index('team')['goalkeeper_score'])) | |
pred_set.insert(5, 'Team2_Goalkeeper_Score', | |
pred_set['Team2'].map(last_team_scores.set_index('team')['goalkeeper_score'])) | |
pred_set.insert(6, 'Team1_Defense', pred_set['Team1'].map(last_team_scores.set_index('team')['defense_score'])) | |
pred_set.insert(7, 'Team1_Offense', pred_set['Team1'].map(last_team_scores.set_index('team')['offense_score'])) | |
pred_set.insert(8, 'Team1_Midfield', | |
pred_set['Team1'].map(last_team_scores.set_index('team')['midfield_score'])) | |
pred_set.insert(9, 'Team2_Defense', pred_set['Team2'].map(last_team_scores.set_index('team')['defense_score'])) | |
pred_set.insert(10, 'Team2_Offense', pred_set['Team2'].map(last_team_scores.set_index('team')['offense_score'])) | |
pred_set.insert(11, 'Team2_Midfield', | |
pred_set['Team2'].map(last_team_scores.set_index('team')['midfield_score'])) | |
return pred_set | |
def print_results(dataset, y_pred, matches, proba): | |
results = [] | |
for i in range(dataset.shape[0]): | |
print() | |
if y_pred[i] == 2: | |
print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Draw") | |
results.append({'result': 'Draw'}) | |
elif y_pred[i] == 1: | |
print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Winner: " + dataset.iloc[i, 0]) | |
results.append({'result': dataset.iloc[i, 0]}) | |
else: | |
print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Winner: " + dataset.iloc[i, 1]) | |
results.append({'result': dataset.iloc[i, 1]}) | |
try: | |
print('Probability of ' + dataset.iloc[i, 0] + ' winning: ', '%.3f' % (proba[i][1])) | |
print('Probability of Draw: ', '%.3f' % (proba[i][2])) | |
print('Probability of ' + dataset.iloc[i, 1] + ' winning: ', '%.3f' % (proba[i][0])) | |
except: | |
print('Probability of ' + dataset.iloc[i, 1] + ' winning: ', '%.3f' % (proba[i][0])) | |
print("") | |
results = pd.DataFrame(results) | |
matches = pd.concat([matches.group, results], axis=1) | |
return matches | |
def winner_to_match(round, prev_match): | |
round.insert(0, 'c1', round['country1'].map(prev_match.set_index('group')['result'])) | |
round.insert(1, 'c2', round['country2'].map(prev_match.set_index('group')['result'])) | |
round = round.drop(['country1', 'country2'], axis=1) | |
round = round.rename(columns={'c1': 'country1', 'c2': 'country2'}).reset_index(drop=True) | |
return round | |
def prediction_knockout(round): | |
dataset_round = matches(round) | |
prediction_round = xgb_ks_model.predict(dataset_round) | |
proba_round = xgb_ks_model.predict_proba(dataset_round) | |
# prediction_round = ada_ks_model.predict(dataset_round) | |
# proba_round = ada_ks_model.predict_proba(dataset_round) | |
# prediction_round = rf_ks_model.predict(dataset_round) | |
# proba_round = rf_ks_model.predict_proba(dataset_round) | |
results_round = print_results(dataset_round, prediction_round, round, proba_round) | |
return results_round | |
def center_str(round): | |
spaces = ['', ' ', ' ', ' ', ' ', ' ', ] | |
for j in range(2): | |
for i in range(round.shape[0]): | |
if (13 - len(round.iloc[i, j])) % 2 == 0: | |
round.iloc[i, j] = spaces[int((13 - len(round.iloc[i, j])) / 2)] + round.iloc[i, j] + spaces[ | |
int((13 - len(round.iloc[i, j])) / 2)] | |
else: | |
round.iloc[i, j] = spaces[int(((13 - len(round.iloc[i, j])) / 2) - 0.5)] + round.iloc[i, j] + \ | |
spaces[int(((13 - len(round.iloc[i, j])) / 2) + 0.5)] | |
return round | |
def center2(a): | |
spaces = ['', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', | |
' ', ' ', ' ', ' ', ' ', | |
' ', ' ', ' ', ' ', | |
' '] | |
if (29 - len(a)) % 2 == 0: | |
a = spaces[int((29 - len(a)) / 2)] + a + spaces[int((29 - len(a)) / 2)] | |
else: | |
a = spaces[int(((29 - len(a)) / 2) - 0.5)] + a + spaces[int(((29 - len(a)) / 2) + 0.5)] | |
return a | |
dataset_groups = matches(group_matches) | |
dataset_groups.tail() | |
print(dataset_groups) | |
prediction_groups = xgb_gs_model.predict(dataset_groups) | |
proba = xgb_gs_model.predict_proba(dataset_groups) | |
# prediction_groups = ada_gs_model.predict(dataset_groups) | |
# proba = ada_gs_model.predict_proba(dataset_groups) | |
# prediction_groups = rf_gs_model.predict(dataset_groups) | |
# proba = rf_gs_model.predict_proba(dataset_groups) | |
results = print_results(dataset_groups, prediction_groups, group_matches, proba) | |
team_group['points'] = 0 | |
team_group | |
for i in range(results.shape[0]): | |
for j in range(team_group.shape[0]): | |
if results.iloc[i, 1] == team_group.iloc[j, 0]: | |
team_group.iloc[j, 2] += 3 | |
print(team_group.groupby(['group', 'team']).mean().astype(int)) | |
round_of_16 = team_group[team_group['points'] > 5].reset_index(drop=True) | |
round_of_16['group'] = (4 - 1 / 3 * round_of_16.points).astype(int).astype(str) + round_of_16.group | |
round_of_16 = round_of_16.rename(columns={"team": "result"}) | |
round_16 = winner_to_match(round_16, round_of_16) | |
results_round_16 = prediction_knockout(round_16) | |
quarter_finals = winner_to_match(quarter_finals, results_round_16) | |
results_quarter_finals = prediction_knockout(quarter_finals) | |
semi_finals = winner_to_match(semi_finals, results_quarter_finals) | |
results_finals = prediction_knockout(semi_finals) | |
final = winner_to_match(final, results_finals) | |
winner = prediction_knockout(final) | |
second = results_finals[~results_finals.result.isin(winner.result)] | |
results_finals_3 = results_quarter_finals[~results_quarter_finals.result.isin(results_finals.result)] | |
results_finals_3.iloc[0, 0] = 'z1' | |
results_finals_3.iloc[1, 0] = 'z2' | |
second_final = winner_to_match(second_final, results_finals_3) | |
third = prediction_knockout(second_final) | |
round_16 = center_str(round_16) | |
quarter_finals = center_str(quarter_finals) | |
semi_finals = center_str(semi_finals) | |
final = center_str(final) | |
group_matches = center_str(group_matches) | |
# Function to center align text | |
def center(text): | |
return f"<div style='text-align: center;'>{text}</div>" | |
# Function to generate the formatted text | |
def generate_text(round_16, quarter_finals, semi_finals, final): | |
formatted_text = ( | |
round_16.iloc[ | |
0, 0] + 'βββββ βββββ' + | |
round_16.iloc[4, 0] + '\n' + | |
' β β\n' + | |
' βββββ' + quarter_finals.iloc[ | |
0, 0] + 'βββββ βββββ' + | |
quarter_finals.iloc[2, 0] + 'βββββ\n' + | |
' β β β β\n' + | |
round_16.iloc[ | |
0, 1] + 'βββββ β β βββββ' + | |
round_16.iloc[4, 1] + '\n' + | |
' βββββ' + semi_finals.iloc[ | |
0, 0] + 'βββββ βββββ' + semi_finals.iloc[1, 0] + 'βββββ\n' + | |
round_16.iloc[ | |
1, 0] + 'βββββ β β β β βββββ' + | |
round_16.iloc[5, 0] + '\n' + | |
' β β β β β β\n' + | |
' βββββ' + quarter_finals.iloc[ | |
0, 1] + 'βββββ β β βββββ' + | |
quarter_finals.iloc[2, 1] + 'βββββ\n' + | |
' β β β β\n' + | |
round_16.iloc[ | |
1, 1] + 'βββββ β β βββββ' + | |
round_16.iloc[5, 1] + '\n' + | |
' βββββ' + final.iloc[0, 0] + 'vs.' + | |
final.iloc[0, 1] + 'βββββ\n' + | |
round_16.iloc[ | |
2, 0] + 'βββββ β β βββββ' + | |
round_16.iloc[6, 0] + '\n' + | |
' β β β β\n' + | |
' βββββ' + quarter_finals.iloc[ | |
1, 0] + 'βββββ β β βββββ' + | |
quarter_finals.iloc[3, 0] + 'βββββ\n' + | |
' β β β β β β\n' + | |
round_16.iloc[ | |
2, 1] + 'βββββ β β β β βββββ' + | |
round_16.iloc[6, 1] + '\n' + | |
' βββββ' + semi_finals.iloc[ | |
0, 1] + 'βββββ βββββ' + semi_finals.iloc[1, 1] + 'βββββ\n' + | |
round_16.iloc[ | |
3, 0] + 'βββββ β β βββββ' + | |
round_16.iloc[7, 0] + '\n' + | |
' β β β β\n' + | |
' βββββ' + quarter_finals.iloc[ | |
1, 1] + 'βββββ βββββ' + | |
quarter_finals.iloc[3, 1] + 'βββββ\n' + | |
' β β\n' + | |
round_16.iloc[ | |
3, 1] + 'βββββ βββββ' + | |
round_16.iloc[7, 1] + '\n' + | |
" " + center( | |
"\U0001F947" + winner.iloc[0, 1]) + '\n' + | |
" " + center( | |
"\U0001F948" + second.iloc[0, 1]) + '\n' + | |
" " + center( | |
"\U0001F949" + third.iloc[0, 1]) | |
) | |
return formatted_text | |
# Generate the formatted text | |
formatted_text = generate_text(round_16, quarter_finals, semi_finals, final) | |
# Define the round_16, quarter_finals, semi_finals, final DataFrames | |
# Replace the DataFrame creation with your actual data | |
# Display the formatted text | |
st.text(formatted_text) | |
# st.markdown(formatted_text) | |
print(round_16.iloc[ | |
0, 0] + 'βββββ βββββ' + | |
round_16.iloc[4, 0]) | |
print( | |
' β β') | |
print(' βββββ' + quarter_finals.iloc[ | |
0, 0] + 'βββββ βββββ' + | |
quarter_finals.iloc[2, 0] + 'βββββ') | |
print( | |
' β β β β') | |
print(round_16.iloc[ | |
0, 1] + 'βββββ β β βββββ' + | |
round_16.iloc[4, 1]) | |
print(' βββββ' + semi_finals.iloc[ | |
0, 0] + 'βββββ βββββ' + semi_finals.iloc[1, 0] + 'βββββ') | |
print(round_16.iloc[ | |
1, 0] + 'βββββ β β β β βββββ' + | |
round_16.iloc[5, 0]) | |
print( | |
' β β β β β β') | |
print(' βββββ' + quarter_finals.iloc[ | |
0, 1] + 'βββββ β β βββββ' + | |
quarter_finals.iloc[2, 1] + 'βββββ') | |
print( | |
' β β β β') | |
print(round_16.iloc[ | |
1, 1] + 'βββββ β β βββββ' + | |
round_16.iloc[5, 1]) | |
print(' βββββ' + final.iloc[0, 0] + 'vs.' + final.iloc[ | |
0, 1] + 'βββββ') | |
print(round_16.iloc[ | |
2, 0] + 'βββββ β β βββββ' + | |
round_16.iloc[6, 0]) | |
print( | |
' β β β β') | |
print(' βββββ' + quarter_finals.iloc[ | |
1, 0] + 'βββββ β β βββββ' + | |
quarter_finals.iloc[3, 0] + 'βββββ') | |
print( | |
' β β β β β β') | |
print(round_16.iloc[ | |
2, 1] + 'βββββ β β β β βββββ' + | |
round_16.iloc[6, 1]) | |
print(' βββββ' + semi_finals.iloc[ | |
0, 1] + 'βββββ βββββ' + semi_finals.iloc[1, 1] + 'βββββ') | |
print(round_16.iloc[ | |
3, 0] + 'βββββ β β βββββ' + | |
round_16.iloc[7, 0]) | |
print( | |
' β β β β') | |
print(' βββββ' + quarter_finals.iloc[ | |
1, 1] + 'βββββ βββββ' + | |
quarter_finals.iloc[3, 1] + 'βββββ') | |
print( | |
' β β') | |
print(round_16.iloc[ | |
3, 1] + 'βββββ βββββ' + | |
round_16.iloc[7, 1]) | |
print( | |
" " + center2("\U0001F947" + winner.iloc[0, 1])) | |
print( | |
" " + center2("\U0001F948" + second.iloc[0, 1])) | |
print( | |
" " + center2("\U0001F949" + third.iloc[0, 1])) | |
if __name__ == "__main__": | |
main() | |