simulate.py

proba = {'Manchester City': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Bayern Munich': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Paris Saint-Germain': {'qtr': 300, 'semi': 0, 'final': 0, 'champion': 0},
        'Real Madrid': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Juventus': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Lyon': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Barcelona': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Napoli': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Chelsea': {'qtr': 0, 'semi': 0, 'final': 0, 'champion': 0},
        'Atalanta': {'qtr': 300, 'semi': 0, 'final': 0, 'champion': 0},
        'RB Leipzig': {'qtr': 300, 'semi': 0, 'final': 0, 'champion': 0},
        'Atletico Madrid': {'qtr': 300, 'semi': 0, 'final': 0, 'champion': 0}}

def simulate():
    overSampled_bo = BayesianOptimization(
             xgb_cv,
             {'eta': (0.01, 0.3),
             'min_child_weight': (1, 25),
             'max_depth': (3, 5),
             'gamma': (0.0, 1.0),
             'subsample': (0.5, 1),
             'colsample_bytree': (0.5, 1),
             'alpha': (0.0, 2.0),
             'n_estimators': (90, 100),
             'learning_rate': (0.0001, 0.1)})
    overSampled_bo.maximize()
    overSampled_xgb_optimized = xgb.XGBClassifier(alpha=overSampled_bo.max['params']['alpha'], colsample_bytree=overSampled_bo.max['params']['colsample_bytree'], 
                                                  eta=overSampled_bo.max['params']['eta'], gamma=overSampled_bo.max['params']['gamma'], 
                                                  max_depth=int(overSampled_bo.max['params']['max_depth']), min_child_weight=overSampled_bo.max['params']['min_child_weight'], 
                                                  subsample=overSampled_bo.max['params']['subsample'], n_estimators=int(overSampled_bo.max['params']['n_estimators']),
                                                  learning_rate=overSampled_bo.max['params']['learning_rate'], random_state=42)
    overSampled_xgb_optimized = MultiOutputRegressor(overSampled_xgb_optimized)
    overSampled_xgb_optimized.fit(X, y)
    # round of 16
    predicted_results = overSampled_xgb_optimized.predict(future_games_pca)
    winners = []
    for i in range(4):
        winner = winner_judgment(future_games[['Home', 'Away']].iloc[i], predicted_results[i][0], predicted_results[i][1], True, 
                                       int(leg_1['Away_Score'].iloc[i]), int(leg_1['Home_Score'].iloc[i]))
        winners.append(winner)
        proba[winner]['qtr'] += 1

    # quarter finals
    quarterFinals = pd.DataFrame({'Home': [winners[1], 'Atletico Madrid', winners[3], 'Paris Saint-Germain'],
                                 'Away': [winners[0], 'RB Leipzig', winners[2], 'Atalanta']})
    quarterFinals = quarterFinals.merge(aggregate, left_on='Home', right_on='Squad')
    quarterFinals = quarterFinals.merge(aggregate, left_on='Away', right_on='Squad', suffixes=('_Home', '_Away'))
    quarterFinals = quarterFinals.drop(columns=['Squad_Home', 'Squad_Away'])
    quarterFinals_pca = pca.transform(quarterFinals.drop(columns=['Home', 'Away']))
    quarterFinalPrediction = overSampled_xgb_optimized.predict(quarterFinals_pca)
    semi_qualifiers = []
    for i in range(4):
        semi_quafier = winner_judgment(quarterFinals[['Home', 'Away']].iloc[i], quarterFinalPrediction[i][0], quarterFinalPrediction[i][1])
        semi_qualifiers.append(semi_quafier)
        proba[semi_quafier]['semi'] += 1

    # semi finals
    semiFinals = pd.DataFrame({'Home': [semi_qualifiers[2], semi_qualifiers[3]],
                                 'Away': [semi_qualifiers[0], semi_qualifiers[1]]})
    semiFinals = semiFinals.merge(aggregate, left_on='Home', right_on='Squad')
    semiFinals = semiFinals.merge(aggregate, left_on='Away', right_on='Squad', suffixes=('_Home', '_Away'))
    semiFinals = semiFinals.drop(columns=['Squad_Home', 'Squad_Away'])
    semiFinals_pca = pca.transform(semiFinals.drop(columns=['Home', 'Away']))
    semiFinalsPrediction = overSampled_xgb_optimized.predict(semiFinals_pca)
    finalists = []
    for i in range(2):
        finalist = winner_judgment(semiFinals[['Home', 'Away']].iloc[i], semiFinalsPrediction[i][0], semiFinalsPrediction[i][1])
        finalists.append(finalist)
        proba[finalist]['final'] += 1

    # final
    Finals = pd.DataFrame({'Home': [finalists[1]],
                                 'Away': [finalists[0]]})
    Finals = Finals.merge(aggregate, left_on='Home', right_on='Squad')
    Finals = Finals.merge(aggregate, left_on='Away', right_on='Squad', suffixes=('_Home', '_Away'))
    Finals = Finals.drop(columns=['Squad_Home', 'Squad_Away'])
    Finals_pca = pca.transform(Finals.drop(columns=['Home', 'Away']))
    FinalPrediction = overSampled_xgb_optimized.predict(Finals_pca)
    champion = winner_judgment(Finals[['Home', 'Away']].iloc[0], FinalPrediction[0][0], FinalPrediction[0][1])
    proba[champion]['champion'] += 1