<jupyter_start><jupyter_text>PROJET FINAL MAG3 : Prédictions de cotes  DIFERNAND Audrey, <NAME>  Pour ce projet, nous avons choisi de nous intéresser aux matchs de Premier League, championnat de football en Angleterre entre 2006 et 2016. Nous utilisons deux bases de données différentes: la première est la table "stats" avec des données sur chaque équipe, chaque saison de 2006-2007 à 2016-2017, le deuxième type de bases de données concerne des tables par saison, récapitulant les données par match où se trouve les données sur les côtes de paris sportifs. Dans un premier temps, on organisera les données afin de pouvoir les utiliser correctement. Puis, nous réaliserons quelques statistiques descriptives. Enfin, nous tenterons de prédire la côte au temps t à partir de variables au temps t-1, notamment de la côte au temps t-1.  Data Preparation  Importation des packages nécessaires<jupyter_code>import pandas as pd 
import matplotlib.pyplot as plt
import numpy as np 
%matplotlib inline

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
import  statsmodels.formula.api as sm
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression
from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix  

from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve

import seaborn as sns

import statsmodels.api as sm<jupyter_output><empty_output><jupyter_text>Importation des données<jupyter_code>stats = pd.read_csv('stats.csv', sep=";")
odd6= pd.read_csv('E6.csv',sep=';')
odd7= pd.read_csv('E7.csv',sep=';')
odd8= pd.read_csv('E8.csv',sep=';')
odd9= pd.read_csv('E9.csv',sep=';')
odd10= pd.read_csv('E10.csv',sep=';')
odd11= pd.read_csv('E11.csv',sep=';')
odd12= pd.read_csv('E12.csv',sep=';')
odd13= pd.read_csv('E13.csv',sep=';')
odd14= pd.read_csv('E14.csv',sep=';')
odd15= pd.read_csv('E15.csv',sep=';')
odd16= pd.read_csv('E16.csv',sep=';')<jupyter_output><empty_output><jupyter_text>Nettoyage des tables  On ne garde que les variables qui nous intéressent : la date et le résultat du match, l'équipe à domicile, l'équipe à l'extérieur, le nombre de buts, de tirs, de tirs cadrés, de corners, de fautes, de cartons jaunes, de cartons rouges pour les deux équipes. Nous avons également le nombre de buts et le résultat à la mi-temps et les côtes de paris sportifs sur BET365.<jupyter_code>odd6 = odd6[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
            'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
            'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd7 = odd7[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
            'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
            'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd8 = odd8[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
            'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
            'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd9 = odd9[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
            'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
            'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd10 = odd10[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd11 = odd11[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd12 = odd12[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd13 = odd13[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd14 = odd14[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd15 = odd15[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd16 = odd16[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','HTHG','HTAG','HTR','Referee','HS',
            'AS','HST','AST','HC','AC','HF','AF','HY','AY','HR','AR','B365H','B365A','B365D',
              'BbMxH','BbAvH','BbMxD','BbAvD','BbMxA','BbAvA',
              'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5', 'BbAv<2.5']]
odd6['season'] = '2006-2007'
odd7['season'] = '2007-2008'
odd8['season'] = '2008-2009'
odd9['season'] = '2009-2010'
odd10['season'] = '2010-2011'
odd11['season'] = '2011-2012'
odd12['season'] = '2012-2013'
odd13['season'] = '2013-2014'
odd14['season'] = '2014-2015'
odd15['season'] = '2015-2016'
odd16['season'] = '2016-2017'<jupyter_output><empty_output><jupyter_text>Fusion des tables de matchs<jupyter_code>df = pd.concat([odd6,odd7,odd8,odd9,odd10,odd11,odd12,odd13,odd14,odd15,odd16], axis=0, join='outer')
df.columns
df.head()<jupyter_output><empty_output><jupyter_text>Data exploration Moyenne des différentes variables présentes dans la base finale:<jupyter_code>print("Nombre moyen de buts pour l'équipe à domicile",df['FTHG'].mean())
print("Nombre moyen de buts  pour l'équipe à l'extérieur",df['FTAG'].mean())
print("Nombre moyen de tirs cadrés pour l'équipe à domicile",df['HST'].mean())
print("Nombre moyen de tirs cadrés pour l'équipe à l'extérieur",df['AST'].mean())
print("Nombre moyen de fautes commises par l'équipe à domicile",df['HF'].mean())
print("Nombre moyen de fautes commises par l'équipe à l'extérieur",df['AF'].mean())
print("Nombre moyen de corners pour l'équipe à domicile",df['HC'].mean())
print("Nombre moyen de corners pour l'équipe à l'extérieur",df['AC'].mean())
print("Nombre moyen de cartons jaunes pour l'équipe à domicile",df['HY'].mean())
print("Nombre moyen de cartons jaunes pour l'équipe à l'extérieur",df['AY'].mean())
print("Nombre moyen de cartons rouges pour l'équipe à domicile",df['HR'].mean())
print("Nombre moyen de cartons rouges pour l'équipe à l'extérieur",df['AR'].mean())
print("cote moyenne à domicile",df['B365H'].mean())
print("cote moyenne à l'exétieur",df['B365A'].mean())
print("cote moyenne du match nul",df['B365D'].mean())<jupyter_output>cote moyenne à domicile 2.7196148325358656
cote moyenne à l'exétieur 4.906976076555013
cote moyenne du match nul 3.933976076554991<jupyter_text>Création de la variable de comparaison utile afin savoir si le résultat à la mi-temps (HTR: half-time result) est le même qu'à la fin du match (FTR: full-time result)<jupyter_code>compar = np.array(df['FTR'] == df['HTR'])
df['compar'] = compar.astype('str')
df['compar'].value_counts().plot(kind='pie', title = 'Resultat mi-temps = Resultat Final ?', autopct='%.2f')<jupyter_output><empty_output><jupyter_text>Pour 6 matchs sur 10, le résultat à la mi-temps est confirmé à la fin du temps règlemantaire. Intéressons-nous plus précisement au résultat final dans les 3 cas suivants à la mi-temps: lorsque l'équipe à domicile est mène, lorsque l'équipe jouant à l'extérieur mène et lorsque qu'il y a égalité entre les deux équipes.<jupyter_code>half_home = df.loc[df['HTR'] == 'H']
half_home['FTR'].value_counts().plot(kind='pie', title = "Résultat final si l'équipe à domicile est gagnante à la mi-temps", autopct='%.2f')<jupyter_output><empty_output><jupyter_text>Nous observons que dans plus de 80% des matchs les équipes qui ont l'avantage à la mi-temps confirment cet avantage en gagnant le match à la fin du temps règlementaire.<jupyter_code>half_away = df.loc[df['HTR'] == 'A']
half_away['FTR'].value_counts().plot(kind='pie',title = "Résultat final si l'équipe à l'extérieur est gagnante à la mi-temps", autopct='%.2f')<jupyter_output><empty_output><jupyter_text>Même si une très grande proportion des matchs menés à la mi-temps par l'équipe extérieure est gagnée par cette même équipe, pour 30% des matchs, ce n'est pas le cas et l'équipe à domicile peut revenir au match nul ou renverser le match et le gagner.<jupyter_code>half_away = df.loc[df['HTR'] == 'D']
half_away['FTR'].value_counts().plot(kind='pie',title = "Résultat final si match nul à la mi-temps", autopct='%.2f')<jupyter_output><empty_output><jupyter_text>Ici, il est intéressant de voir qu'à la mi-temps rien est joué, même si d'après les statistiques, l'issue du match semble moins favorable à la victoire de l'équipe à l'extérieur. Création de la variable dichotomique correspondant la victoire de l'équipe à domicile, la victoire de l'équipe jouant à l'extérieur ou au match nul<jupyter_code>df['Home_Win'] = np.where(df['FTR'] == 'H',1,0)
df['Away_Win'] = np.where(df['FTR'] == 'A',1,0)
df['Draw'] = np.where(df['FTR'] == 'D',1,0)
df.groupby(['FTR'])['season'].value_counts().unstack(0).plot.bar(stacked=True,title="Type de Résultat selon les saisons", figsize=(14,8))
df.groupby(['FTR'])['HTR'].value_counts().unstack(0).plot.bar(stacked=True,title="FTR = f(HTR)", figsize=(14,8))
df.groupby(['FTR'])['AS'].value_counts().unstack(0).plot.bar(stacked=True,title="FTR = f(home shoots)", figsize=(14,8))
df.groupby(['FTR'])['FTHG'].value_counts().unstack(0).plot.bar(stacked=True,title="FTR = f(home goals)", figsize=(14,8))
df.groupby(['FTR'])['HTHG'].value_counts().unstack(0).plot.bar(stacked=True,title="FTR = f(home goals)", figsize=(14,8))<jupyter_output><empty_output><jupyter_text>Manipulation de tables afin d'obtenir les données générales des matchs sur toutes les saisons en une table<jupyter_code>sum_home = df['HS'].groupby([df['season'], 
                             df['HomeTeam']]).sum().reset_index()
sum_away = df['AS'].groupby([df['season'], 
                             df['AwayTeam']]).sum().reset_index()
sum_home = pd.merge(sum_home,
                    df['Home_Win'].groupby([df['season'], 
                                                     df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['Away_Win'].groupby([df['season'], 
                                            df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['Draw'].groupby([df['season'], 
                                        df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['Draw'].groupby([df['season'], 
                                        df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,df['FTHG'].groupby([df['season'], 
                                                 df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['FTAG'].groupby([df['season'], 
                                        df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HST'].groupby([df['season'], 
                                       df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['AST'].groupby([df['season'], 
                                       df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HF'].groupby([df['season'], 
                                      df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['AF'].groupby([df['season'], 
                                      df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HC'].groupby([df['season'], 
                                      df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['AC'].groupby([df['season'], 
                                      df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HY'].groupby([df['season'], 
                                      df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['AY'].groupby([df['season'], 
                                               df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HR'].groupby([df['season'], 
                                      df['HomeTeam']]).sum().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['AR'].groupby([df['season'], 
                                      df['AwayTeam']]).sum().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['B365H'].groupby([df['season'], 
                                         df['HomeTeam']]).mean().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['B365A'].groupby([df['season'], 
                                         df['AwayTeam']]).mean().reset_index(),
                    on =['AwayTeam','season'])
sum_home = pd.merge(sum_home,
                    df['HTHG'].groupby([df['season'], 
                                        df['HomeTeam']]).mean().reset_index(),
                    on =['HomeTeam','season'])
sum_away = pd.merge(sum_away,
                    df['HTAG'].groupby([df['season'], 
                                        df['AwayTeam']]).mean().reset_index(),
                    on =['AwayTeam','season'])
sum_home = sum_home.rename(columns={'HomeTeam': 'team', 'B365H':'home_odd', 'Draw': 'Draw_at_home'})
sum_away = sum_away.rename(columns={'AwayTeam': 'team', 'B365A':'away_odd', 'Draw': 'Draw_away'})
sum_merge = pd.merge(sum_home,
                     sum_away, on = ['team','season'])
sum_merge.head()
sum_stat_merge = pd.merge(stats,sum_merge, 
                          on = ['team','season'])
sum_stat_merge.info()
sum_stat_merge.head()
home_odd = pd.DataFrame(df['B365H'].groupby([df['HomeTeam'], 
                                             df['season']]).mean().reset_index())
away_odd = pd.DataFrame(df['B365A'].groupby([df['AwayTeam'], 
                                             df['season']]).mean().reset_index())
draw_odd_home = pd.DataFrame(df['B365D'].groupby([df['HomeTeam'], 
                                                  df['season']]).mean().reset_index())
draw_odd_away = pd.DataFrame(df['B365D'].groupby([df['AwayTeam'], 
                                                  df['season']]).mean().reset_index())
away_odd = away_odd.rename(columns={'AwayTeam': 'team'})
home_odd = home_odd.rename(columns={'HomeTeam': 'team'})
draw_odd_home = draw_odd_home.rename(columns={'HomeTeam': 'team'})
draw_odd_away = draw_odd_away.rename(columns={'AwayTeam': 'team'})
merged = pd.merge(stats,away_odd, 
                  on=['team','season'], 
                  how='left')
merged = pd.merge(merged,home_odd, 
                  on=['team','season'], 
                  how='left')
merged = pd.merge(merged,draw_odd_away, 
                  on=['team','season'], 
                  how='left')
merged = pd.merge(merged,draw_odd_home, 
                  on=['team','season'], 
                  how='left')
merged = merged.rename(columns={'B365A': 'mean_away_odd', 'B365H' : 'mean_home_odd',
                               'B365D_x': 'mean_draw_away_odd', 'B365D_y':'mean_draw_home_odd'})
merged.head()
merged.head()
away_sort =  merged.sort_values(by = ['season','mean_home_odd'], 
                                ascending = True)
away = away_sort[['season','team','classement','mean_away_odd']]
away['classement_odd'] = away.groupby('season')['team'].cumcount() + 1<jupyter_output>C:\Users\marie\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
  """Entry point for launching an IPython kernel.<jupyter_text>Dans les prochains codes, nous allons comparer le classement final par saison et le classement effectué à partir de la moyenne des côtes sur la saison. Il est difficile d'avoir exactement le même classement c'est pourquoi nous créons des classes: par exemple, si le classement final est compris entre 1 et 5 et que le classement par côte est également compris entre 1 et 5, nous estimons que la prédiction venant des paris sportifs est bonne.<jupyter_code>import operator
conditions = [
    (operator.and_(away['classement']<=5, away['classement_odd']<=5)),
    (operator.and_(operator.and_(away['classement'] > 5,away['classement'] <= 10), 
                   operator.and_(away['classement_odd'] > 5,away['classement_odd'] <= 10))),
    (operator.and_(operator.and_(away['classement'] > 10,away['classement'] <= 15), 
                    operator.and_(away['classement_odd'] > 10,away['classement_odd'] <= 15))),
    (operator.and_(operator.and_(away['classement'] > 15,away['classement'] <= 20), 
                   operator.and_(away['classement_odd'] > 15,away['classement_odd'] <= 20)))
                   ]
choices = ['Bonne prédiction', 'Bonne prédiction', 'Bonne prédiction','Bonne prédiction']
away['compar'] = np.select(conditions, choices, default='Mauvaise prédiction')
away.head(20)
home_sort = merged.sort_values(by = ['season','mean_home_odd'], ascending = True)
home = home_sort[['season','team','classement','mean_home_odd']]
home['classement_odd'] = home.groupby('season').cumcount() + 1
conditions = [
    (operator.and_(home['classement']<=5, home['classement_odd']<=5)),
    (operator.and_(operator.and_(home['classement'] > 5,home['classement'] <= 10), 
                   operator.and_(home['classement_odd'] > 5,home['classement_odd'] <= 10))),
    (operator.and_(operator.and_(home['classement'] > 10,home['classement'] <= 15), 
                   operator.and_(home['classement_odd'] > 10,home['classement_odd'] <= 15))),
    (operator.and_(operator.and_(home['classement'] > 15,home['classement'] <= 20), 
                   operator.and_(home['classement_odd'] > 15,home['classement_odd'] <= 20)))
                   ]
choices = ['Bonne prédiction', 'Bonne prédiction', 'Bonne prédiction','Bonne prédiction']
home['compar'] = np.select(conditions, choices, default='Mauvaise prédiction')

home.head(20)<jupyter_output><empty_output><jupyter_text>Modélisation<jupyter_code>sum_stat_merge.head()
sum_stat_merge.columns<jupyter_output><empty_output><jupyter_text>Nous décidons d'effectuer une régression linéaire pour essayer de voir si la cote moyenne de l'année N est influencée par les statistiques de l'année N-1. Pour cela, nous devons créer des variables retardées :<jupyter_code>features=['classement', 'wins', 'losses', 'goals',
       'total_yel_card', 'total_red_card', 'total_scoring_att',
       'ontarget_scoring_att', 'hit_woodwork', 'att_hd_goal', 'att_pen_goal',
       'att_freekick_goal', 'att_ibox_goal', 'att_obox_goal', 'goal_fastbreak',
       'total_offside', 'clean_sheet', 'goals_conceded',
       'outfielder_block', 'interception', 'total_tackle', 'last_man_tackle',
       'total_clearance', 'own_goals', 'penalty_conceded',
       'pen_goals_conceded', 'total_pass',
       'total_long_balls', 'total_cross', 'corner_taken',
       'touches', 'clearance_off_line', 'dispossessed',
       'penalty_save', 'total_high_claim', 'punches', 'HS', 'Home_Win',
       'Draw_at_home', 'FTHG', 'HST', 'HF', 'HC', 'HY', 'HR', 'home_odd',
       'HTHG', 'AS', 'Away_Win', 'Draw_away', 'FTAG', 'AST', 'AF', 'AC', 'AY',
       'AR', 'away_odd', 'HTAG']
for f in features:
    sum_stat_merge[f + '_lag']=sum_stat_merge.groupby('team')[f].shift(1)<jupyter_output><empty_output><jupyter_text>Nous enlevons les valeurs manquantes afin qu'elles ne soient pas prises en compte.<jupyter_code>sum_stat_merge.dropna(axis=0, inplace=True)<jupyter_output><empty_output><jupyter_text>Nous ne gardons que les variables qui nous intéressent.<jupyter_code>df_model = sum_stat_merge[['classement_lag', 'wins_lag', 'losses_lag', 'goals_lag',
       'total_yel_card_lag', 'total_red_card_lag', 'total_scoring_att_lag',
       'ontarget_scoring_att_lag', 'hit_woodwork_lag', 'att_hd_goal_lag', 'att_pen_goal_lag',
       'att_freekick_goal_lag', 'att_ibox_goal_lag', 'att_obox_goal_lag', 'goal_fastbreak_lag',
       'total_offside_lag', 'clean_sheet_lag', 'goals_conceded_lag',
       'outfielder_block_lag', 'interception_lag', 'total_tackle_lag', 'last_man_tackle_lag',
       'total_clearance_lag', 'own_goals_lag', 'penalty_conceded_lag',
       'pen_goals_conceded_lag', 'total_pass_lag',
       'total_long_balls_lag', 'total_cross_lag', 'corner_taken_lag',
       'touches_lag', 'clearance_off_line_lag', 'dispossessed_lag',
       'penalty_save_lag', 'total_high_claim_lag', 'punches_lag', 'HS_lag', 'Home_Win_lag',
       'Draw_at_home_lag', 'FTHG_lag', 'HST_lag', 'HF_lag', 'HC_lag', 'HY_lag', 'HR_lag', 'home_odd_lag',
       'HTHG_lag', 'AS_lag', 'Away_Win_lag', 'Draw_away_lag', 'FTAG_lag', 'AST_lag', 'AF_lag','AC_lag', 'AY_lag',
       'AR_lag', 'away_odd_lag', 'HTAG_lag','home_odd']]<jupyter_output><empty_output><jupyter_text>Nous séparons le dataset en un échantillon d'apprentissage et un autre où nous testerons le modèle.<jupyter_code>from sklearn.model_selection import train_test_split
X = sum_stat_merge[['classement_lag', 'wins_lag', 'losses_lag', 'goals_lag',
       'total_yel_card_lag', 'total_red_card_lag', 'total_scoring_att_lag',
       'ontarget_scoring_att_lag', 'hit_woodwork_lag', 'att_hd_goal_lag', 'att_pen_goal_lag',
       'att_freekick_goal_lag', 'att_ibox_goal_lag', 'att_obox_goal_lag', 'goal_fastbreak_lag',
       'total_offside_lag', 'clean_sheet_lag', 'goals_conceded_lag',
       'outfielder_block_lag', 'interception_lag', 'total_tackle_lag', 'last_man_tackle_lag',
       'total_clearance_lag', 'own_goals_lag', 'penalty_conceded_lag',
       'pen_goals_conceded_lag', 'total_pass_lag',
       'total_long_balls_lag', 'total_cross_lag', 'corner_taken_lag',
       'touches_lag', 'clearance_off_line_lag', 'dispossessed_lag',
       'penalty_save_lag', 'total_high_claim_lag', 'punches_lag', 'HS_lag', 'Home_Win_lag',
       'Draw_at_home_lag', 'FTHG_lag', 'HST_lag', 'HF_lag', 'HC_lag', 'HY_lag', 'HR_lag', 'home_odd_lag',
       'HTHG_lag', 'AS_lag', 'Away_Win_lag', 'Draw_away_lag', 'FTAG_lag', 'AST_lag', 'AF_lag','AC_lag', 'AY_lag',
       'AR_lag', 'away_odd_lag', 'HTAG_lag']]
y = sum_stat_merge['home_odd']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
est = sm.OLS(y_train, X_train)
est2 = est.fit()
print(est2.summary())<jupyter_output>OLS Regression Results                            
==============================================================================
Dep. Variable:               home_odd   R-squared:                       0.928
Model:                            OLS   Adj. R-squared:                  0.820
Method:                 Least Squares   F-statistic:                     8.616
Date:                Sat, 30 Mar 2019   Prob (F-statistic):           4.28e-10
Time:                        00:01:40   Log-Likelihood:                 1.6661
No. Observations:                  91   AIC:                             106.7
Df Residuals:                      36   BIC:                             244.8
Df Model:                          54                                         
Covariance Type:            nonrobust                                         
============================================================================================
                               coef   [...]<jupyter_text>Nous avons inclu dans ce modèle l'ensemble des variables présentes dans la table. Nous voyons que le R² est à 0.93 ce qui peut paraitre très bon. Toutefois, le modèle ici présent est loin d'être optimal puisqu'énormément de variables ne sont pas significaitves et que nous avons un probèle de multicolinéarité. Nous recommençons la même démarche en intégrant dans le modèle uniquement les variables qui étaient significatives précédemment.<jupyter_code>X = sum_stat_merge[['HR_lag','Draw_at_home_lag','Home_Win_lag',
'HS_lag','att_freekick_goal_lag','total_red_card_lag',
'total_scoring_att_lag',
'classement_lag']]
y = sum_stat_merge['home_odd']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
est = sm.OLS(y_train, X_train)
est3 = est.fit()
print(est3.summary())<jupyter_output>OLS Regression Results                            
==============================================================================
Dep. Variable:               home_odd   R-squared:                       0.975
Model:                            OLS   Adj. R-squared:                  0.973
Method:                 Least Squares   F-statistic:                     409.5
Date:                Sat, 30 Mar 2019   Prob (F-statistic):           2.57e-63
Time:                        00:02:08   Log-Likelihood:                -54.422
No. Observations:                  91   AIC:                             124.8
Df Residuals:                      83   BIC:                             144.9
Df Model:                           8                                         
Covariance Type:            nonrobust                                         
=========================================================================================
                            coef    std e[...]<jupyter_text>Nous n'avons plus de problème de colinéarité et le R² a même augmenté. Néanmoins, du fait de la spécificité des variables que nous avons ici. Il se pourrait que d'autres modèles soient plus performants et mettent en lumière plus de relations entre nos variables.<jupyter_code>est_df = pd.DataFrame()
est_df['True Y'] = y_test
est_df['Predicted Y'] = est3.predict(X_test)
est_df['Diff'] = (est_df['True Y'] - est_df['Predicted Y'])
def rmse(predictions, targets):
    return np.sqrt(((predictions - targets) ** 2).mean())
est_df.head()
rmse(est_df['Predicted Y'],est_df['True Y'])
est_df['Diff'].plot(kind='hist')<jupyter_output><empty_output><jupyter_text>Nous nous sommes ensuite interessées à la probabilité que l'équipe à domicile gagne le match. Pour ce faire, nous avons utilisé la Régression Logistique.<jupyter_code>from sklearn.linear_model import LogisticRegression
from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix  

from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
df.head()<jupyter_output><empty_output><jupyter_text>Nous avons créé ici notre variable dépendante dichotomique et nous effectuons quelques statistiques descriptives.<jupyter_code>df['Home_Win'].value_counts()
sns.countplot(x='Home_Win', data=df, palette='hls')
plt.show()
count_loss = len(df[df['Home_Win']==0])
count_win = len(df[df['Home_Win']==1])
pct_of_win = (count_win/(count_win+count_loss))*100
print("Pourcentage de matchs gagnés par l'équipe à domicile", pct_of_win)
pct_of_loss = (count_loss/(count_win+count_loss))*100
print("Pourcentage de matchs perdus par l'équipe à domicile", pct_of_loss)
df.groupby('Home_Win').mean()
df.columns
X = df[['HTHG', 'HTAG',
        'HS', 'AS', 'HST', 'AST', 'HC', 'AC', 'HF', 'AF',
       'HY', 'AY', 'HR', 'AR', 'B365H', 'B365A', 'B365D', 'BbMxH', 'BbAvH',
       'BbMxD', 'BbAvD', 'BbMxA', 'BbAvA', 'BbMx>2.5', 'BbAv>2.5', 'BbMx<2.5',
       'BbAv<2.5']]
y = df['Home_Win']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
logreg = LogisticRegression(solver='lbfgs', max_iter = 10000)
est = logreg.fit(X_train, y_train.values.ravel())
logit_model=sm.Logit(y_train,X_train)
result=logit_model.fit()
print(result.summary2())<jupyter_output>Optimization terminated successfully.
         Current function value: 0.433804
         Iterations 7
                          Results: Logit
==================================================================
Model:              Logit            Pseudo R-squared: 0.372      
Dependent Variable: Home_Win         AIC:              2592.6211  
Date:               2019-03-30 00:04 BIC:              2754.1187  
No. Observations:   2926             Log-Likelihood:   -1269.3    
Df Model:           26               LL-Null:          -2020.7    
Df Residuals:       2899             LLR p-value:      3.1019e-301
Converged:          1.0000           Scale:            1.0000     
No. Iterations:     7.0000                                        
-------------------------------------------------------------------
               Coef.   Std.Err.     z      P>|z|    [0.025   0.975]
-------------------------------------------------------------------
HTHG           1.4852    0.0817   18.1878  0.0000 [...]<jupyter_text>De manière évidente, toutes les variables ne sont pas significatives mais le modèle semble assez bon.<jupyter_code>y_pred_logit = logreg.predict(X_test)
print('Accuracy of logistic regression classifier on train set: {:.2f}'.format(logreg.score(X_train, y_train)))
print('Accuracy of logistic regression classifier on test set: {:.2f}'.format(logreg.score(X_test, y_test)))<jupyter_output>Accuracy of logistic regression classifier on train set: 0.80
Accuracy of logistic regression classifier on test set: 0.78<jupyter_text>Quasiment 80% des victoires sont prédites correctement.<jupyter_code>print(confusion_matrix(y_test, y_pred_logit))
print(classification_report(y_test, y_pred_logit))
logit_roc_auc = roc_auc_score(y_test, logreg.predict(X_test))
fpr, tpr, thresholds = roc_curve(y_test, logreg.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' % logit_roc_auc)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.18236173393124067, 'fraction_numerical': 0.027840059790732438, 'mean_word_length': 3.4147649161396756, 'pattern_counts': {'":': 0, '<': 128, '<?xml version=': 0, '>': 125, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 45, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '529832', 'license': 'MIT', 'n_tokens_mistral': 11849, 'n_tokens_neox': 11141, 'n_words': 2077, 'path': 'notebooks/Python_project_Difernand_Saugey_MAG3.ipynb', 'repo_name': 'audreydif/projet_foot', 'size': '32118'}