Prédiction de Scores de Match de Premier League Anglaise

Python Sklearn Machine Learning

Contexte du projet

Ce projet de machine learning vise à prédire les scores des matchs de Premier League anglaise en utilisant des données historiques. En exploitant des modèles de régression et des algorithmes d'apprentissage automatique, l'objectif est de fournir des prédictions précises sur les résultats des matchs, en se basant sur des caractéristiques telles que la forme récente des équipes, les statistiques de performance, et d'autres facteurs pertinents.

J'ai essayé plusieurs approches, notamment la régression logistique et les forêts aléatoires, en optimisant les hyperparamètres pour améliorer les performances. Le projet inclut également une analyse approfondie des données pour identifier les caractéristiques les plus influentes dans la prédiction des résultats.

Code Complet

Afficher / masquer le code

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import matplotlib.gridspec as gridspec
from numpy import random
import scipy.stats as scipy
from IPython.display import display
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.ensemble import RandomForestClassifier

def summer_break(team,date,n):
    recent = df[((df['HomeTeam'] == team) | (df['AwayTeam'] == team)) & (df['Date'] < date)]
    recent = recent.sort_values('Date', ascending=False).head(n)
    for i in range (0,len(recent)):
        if recent.iloc[i]['Date'].year != 2020:
            if recent.iloc[i]['Date'].month == 8 and i + 1 < len(recent) and recent.iloc[i + 1]['Date'].month == 5:
                recent = recent.iloc[:i+1]
                break
        else:
            if recent.iloc[i]['Date'].month == 9 and i + 1 < len(recent) and recent.iloc[i + 1]['Date'].month == 7:
                recent = recent.iloc[:i+1]
                break
    return recent
df = pd.read_csv("data/all_seasons.csv",sep=";")   # adapte le nom de fichier
display(df.head())
df['win_or_not'] = (df['FTR'] == 'H').astype(int)  # 1 si victoire domicile, 0 sinon
df['draw_or_lose'] = (df['FTR'] == 'D').astype(int)  # 1 si nul, 0 si défaite
cols=['Unnamed: 0', 'Date', 'HomeTeam', 'AwayTeam', 'FTHG', 'FTAG', 'FTR', 'HTHG', 'HTAG', 'HTR', 'HS', 'AS', 'HST', 'AST', 'HF', 'AF', 'HC', 'AC', 'HY', 'AY', 'HR', 'AR']
df['Date'] = pd.to_datetime(df['Date'], dayfirst=True)
df['result_label'] = df['FTR'].map({
    'H': 'HomeWin',
    'D': 'Draw',
    'A': 'AwayWin'
})
display(df[['HomeTeam','AwayTeam','FTHG','FTAG','FTR','result_label']].head())

home_strength=df.groupby('HomeTeam')['FTHG'].mean()
away_strength=df.groupby('AwayTeam')['FTAG'].mean()
df['home_avg_goals'] = df['HomeTeam'].map(home_strength)
df['away_avg_goals'] = df['AwayTeam'].map(away_strength)

# Feature finale très simple :
df['strength_diff'] = df['home_avg_goals'] - df['away_avg_goals']
#display(df[['HomeTeam','AwayTeam','FTHG','FTAG','FTR','strength_diff']].head())
# X = features, y = label
def forme_recente(equipe, date, n=5):
    recent_matches = df[((df['HomeTeam'] == equipe) | (df['AwayTeam'] == equipe)) & (df['Date'] < date)].sort_values(by='Date', ascending=False).head(n)
    points = 0
    for _, match in recent_matches.iterrows():
        if match['HomeTeam'] == equipe:
            if match['FTR'] == 'H':
                points += 3
            elif match['FTR'] == 'D':
                points += 1
        else:
            if match['FTR'] == 'A':
                points += 3
            elif match['FTR'] == 'D':
                points += 1
    return points
df ['home_recent_form'] = df.apply(lambda row: forme_recente(row['HomeTeam'], row['Date']), axis=1)
df ['away_recent_form'] = df.apply(lambda row: forme_recente(row['AwayTeam'], row['Date']), axis=1)
df['form_diff'] = df['home_recent_form'] - df['away_recent_form']
def forme_saison(equipe, date):
    season_matches = df[((df['HomeTeam'] == equipe) | (df['AwayTeam'] == equipe)) & (df['Date'] < date)]
    points = 0
    for _, match in season_matches.iterrows():
        if match['HomeTeam'] == equipe:
            if match['FTR'] == 'H':
                points += 3
            elif match['FTR'] == 'D':
                points += 1
        else:
            if match['FTR'] == 'A':
                points += 3
            elif match['FTR'] == 'D':
                points += 1
    return points
df ['home_season_form'] = df.apply(lambda row: forme_saison(row['HomeTeam'], row['Date']), axis=1)
df ['away_season_form'] = df.apply(lambda row: forme_saison(row['AwayTeam'], row['Date']), axis=1)
df['season_form_diff'] = df['home_season_form'] - df['away_season_form']

def strength_diff_season(equipe, date):
    season_matches = summer_break(equipe, date, 100)
    if season_matches.empty:
        return 0
    home_goals = season_matches[season_matches['HomeTeam'] == equipe]['FTHG'].sum()
    away_goals = season_matches[season_matches['AwayTeam'] == equipe]['FTAG'].sum()
    total_matches = len(season_matches)
    avg_goals = (home_goals + away_goals) / total_matches
    return avg_goals
df ['home_season_strength'] = df.apply(lambda row: strength_diff_season(row['HomeTeam'], row['Date']), axis=1)
df ['away_season_strength'] = df.apply(lambda row: strength_diff_season(row['AwayTeam'], row['Date']), axis=1)
df['season_strength_diff'] = df['home_season_strength'] - df['away_season_strength']

def recent_offensive_form(team, date, n=5):
    """Buts marqués récemment"""
    recent = summer_break(team, date, n)
    recent = recent.sort_values('Date', ascending=False).head(n)

    goals = 0
    for _, match in recent.iterrows():
        if match['HomeTeam'] == team:
            goals += match['FTHG']
        else:
            goals += match['FTAG']

    return goals / len(recent) if len(recent) > 0 else 0

def recent_defensive_form(team, date, n=5):
    """Buts encaissés récemment"""
    recent = summer_break(team, date, n)
    recent = recent.sort_values('Date', ascending=False).head(n)

    goals_conceded = 0
    for _, match in recent.iterrows():
        if match['HomeTeam'] == team:
            goals_conceded += match['FTAG']
        else:
            goals_conceded += match['FTHG']

    return goals_conceded / len(recent) if len(recent) > 0 else 0

# Applique ces fonctions
df['home_off_form'] = df.apply(lambda x: recent_offensive_form(x['HomeTeam'], x['Date']), axis=1)
df['away_off_form'] = df.apply(lambda x: recent_offensive_form(x['AwayTeam'], x['Date']), axis=1)
df['home_def_form'] = df.apply(lambda x: recent_defensive_form(x['HomeTeam'], x['Date']), axis=1)
df['away_def_form'] = df.apply(lambda x: recent_defensive_form(x['AwayTeam'], x['Date']), axis=1)

df['offensive_advantage'] = df['home_off_form'] - df['away_off_form']
X = df[['offensive_advantage']]

df['defensive_advantage'] = df['away_def_form'] - df['home_def_form']
X = df[['defensive_advantage']]

  # Plus = meilleure défense domicile
df_clean = df.dropna(subset=['strength_diff',  'season_form_diff', 'season_strength_diff','defensive_advantage','offensive_advantage'])
# Ne teste pas tout en même temps !

feature_set = ['strength_diff', 'season_form_diff', 'season_strength_diff', 'defensive_advantage']
X = df_clean[feature_set]
y = df_clean['result_label']
y_win = df_clean['win_or_not']
y_draw = df_clean['draw_or_lose']

# SPLIT PRINCIPAL
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

# Créer y_win et y_draw pour train/test
y_win_train = (y_train == "HomeWin").astype(int)
y_win_test  = (y_test == "HomeWin").astype(int)

y_draw_train = (y_train == "Draw").astype(int)
y_draw_test  = (y_test == "Draw").astype(int)

# --------
# DATASET 2 : uniquement matches NON-gagnés
# --------
non_win_mask_train = (y_win_train == 0)
non_win_mask_test  = (y_win_test == 0)

X_draw_train = X_train[non_win_mask_train]
y_draw_train = y_draw_train[non_win_mask_train]

X_draw_test  = X_test[non_win_mask_test]
y_draw_test  = y_draw_test[non_win_mask_test]


print(f"📊 Données pour le modèle Draw/Lose: {len(X_draw_train)} échantillons")

# Modèles optimisés
models_win = {
    'Random Forest Win': RandomForestClassifier(
        n_estimators=200,
        random_state=42,
        max_depth=10,
        min_samples_leaf=10,
        class_weight='balanced_subsample'
    ),
    'Logistic Regression Win': LogisticRegression(
        solver='lbfgs',
        max_iter=1000,
    )
    , "Random Forest Win custom weights" :RandomForestClassifier(
    n_estimators=150,
    random_state=42,
    max_depth=8,
    min_samples_leaf=15,
    class_weight={0: 1, 1: 3}  # Poids personnalisés
)
}

models_draw = {
    'Random Forest Draw': RandomForestClassifier(
        n_estimators=150,
        random_state=42,
        max_depth=8,
        min_samples_leaf=15,
        class_weight='balanced_subsample'
    ),
    'Logistic Regression Draw': LogisticRegression(
        solver='lbfgs',  # Meilleur pour les petits datasets
        max_iter=1000,
        class_weight='balanced'
    ),
     'Random Forest Draw not balanced': RandomForestClassifier(
        n_estimators=150,
        random_state=42,
        max_depth=8,

    ),
    'Logistic Regression Draw not balanced': LogisticRegression(
        solver='lbfgs',  # Meilleur pour les petits datasets
        max_iter=1000,

    ),'Random Forest Draw custom weights': RandomForestClassifier(
    n_estimators=150,
    random_state=42,
    max_depth=8,
    min_samples_leaf=15,
    class_weight={0: 3, 1: 1}  # Poids personnalisés
)
}

# Entraînement et évaluation
results = []

for win_name, win_model in models_win.items():
    print(f"\n🎯 ENTRAÎNEMENT {win_name}")

    # Modèle Win/NotWin
    win_model.fit(X_train, y_win_train)
    y_win_pred = win_model.predict(X_test)
    win_accuracy = accuracy_score(y_win_test, y_win_pred)

    print(f"Accuracy Win/NotWin: {win_accuracy:.3f}")

    for draw_name, draw_model in models_draw.items():
        print(f"  🔄 Combinaison avec {draw_name}")

        # Modèle Draw/Lose (seulement sur les non-victoires)
        if len(X_draw_train) > 50:  # Assez de données
            draw_model.fit(X_draw_train, y_draw_train)
            # y_draw_pred = draw_model.predict(X_draw_test) # This was the problematic line for combination
            draw_accuracy = accuracy_score(y_draw_test, draw_model.predict(X_draw_test))

            print(f"    Accuracy Draw/Lose: {draw_accuracy:.3f}")

            # Prédictions combinées

            # --- Start of fix ---
            # Create a placeholder for final predictions
            y_final_predictions = np.empty_like(y_test, dtype=object)

            # Assign 'HomeWin' where predicted by the first model
            y_final_predictions[y_win_pred == 1] = "HomeWin"

            # For samples where the first model predicted 'Not HomeWin'
            # Get the subset of X_test for these samples
            X_not_homewin = X_test[y_win_pred == 0]

            if not X_not_homewin.empty:
                # Predict draw/lose for these samples
                y_draw_or_lose_pred = draw_model.predict(X_not_homewin)

                # Get the indices in the original X_test where y_win_pred was 0
                original_indices_not_homewin = np.where(y_win_pred == 0)[0]

                y_final_predictions[original_indices_not_homewin[y_draw_or_lose_pred == 1]] = "Draw"
                y_final_predictions[original_indices_not_homewin[y_draw_or_lose_pred == 0]] = "AwayWin"
            # --- End of fix ---

            y_final = list(y_final_predictions)

            final_accuracy = accuracy_score(y_test, y_final)
            print(y_test, y_final)

            results.append({
                            'Win_Model': win_name,
                            'Draw_Model': draw_name,
                            'Win_Accuracy': win_accuracy,
                            'Draw_Accuracy': draw_accuracy,
                            'Final_Accuracy': final_accuracy,
                            'Win_Samples': len(X_train),
                            'Draw_Samples': len(X_draw_train),

                        })

            print(f"    🎯 Accuracy Finale: {final_accuracy:.3f}")
            print(classification_report(y_test, y_final))
            print(confusion_matrix(y_test, y_final))

# Résultats
results_df = pd.DataFrame(results).sort_values('Final_Accuracy', ascending=False)
print("\n" + "="*60)
print("CLASSEMENT DES COMBINAISONS :")
print(results_df)



                

Conclusion

Projet en pause car trop complexe pour un débutant en ML, mais le code est complet et commenté pour être réutilisé et amélioré. Il nécessite une bonne compréhension du machine learning, de la manipulation de données, et de l'optimisation de modèles. Les résultats sont encourageants mais peuvent être améliorés avec plus de données, des features engineering plus avancées, et des modèles plus complexes. Je suis actuellement en cours de Ml et j'attends la fin du cours pour revenir dessus avec plus de connaissances et d'expérience.

J'ai quand meme atteint un accuracy de 0,51 ce qui est au dessus de 0,33 (prédiction aléatoire) et j'ai pu identifier des features intéressantes pour la prédiction. j'ai aussi perdu le deroulement de mon travail ou je test differentes features mais les buts moyens restait la meilleur. j'ai arreté parce que je n'arrivais pas a comprendre le tableau de resultats suivant :

Résultats

J'ai pas compris comment des modeles peuvent une meilleur Win accuracy et Draw accuracy mais avoir une Final accuracy plus faible, maintenant je sais que c'est parce que les donneés ne sont pas forcement corellees entre elles et que les modeles font des erreurs differentes, du coup la combinaison de leurs erreurs peut faire que la performance finale soit moins bonne que les performances individuelles. C'est un concept important en machine learning, et ça m'a permis de mieux comprendre l'importance de la complémentarité des modèles dans une approche d'ensemble.

Améliorations prévues