Applicazioni pratiche di machine learning

Categoria · Copertina · Sviluppo · Modifica il template

CALCIO

Caricamento librerie

 library(dplyr)
 library(caret)

Parte 1: Dati

Dal seguente link: https://www.football-data.co.uk/italym.php è possibile scaricare le probabilità di vincita, pareggio o vittoria in trasferta di vari bookmakers per le partite di calcio di serie A in Italia . In particolare si utilizzano per la previsione nelle scommesse sportive gli anni 2017,2018,2019,2020 .

Caricamento dati:

 I1_17_18 <- read.csv("I1_17_18.csv")
 I1_18_19 <- read.csv("I1_18_19.csv")
 I1_19_20 <- read.csv("I1_19_20.csv")

Creazione colonna "risultato", contenente gli 1,X,2 risultati della corrispondente partita, da aggiungere al dataframe degli anni 2017 e 2018:

 risultato <- rep(NA,nrow(I1_17_18))
 risultato[which(I1_17_18$FTR=="A")]="2"
 risultato[which(I1_17_18$FTR=="D")]="X"
 risultato[which(I1_17_18$FTR=="H")]="1"

 df1<-I1_17_18[,which(colnames(I1_17_18) %in% colnames(I1_19_20))]
 df1 <- cbind(df1,risultato)

Creazione colonna "risultato", contenente gli 1,X,2 risultati della corrispondente partita, da aggiungere al dataframe degli anni 2018 e 2019:

 risultato <- rep(NA,nrow(I1_18_19))
 risultato[which(I1_18_19$FTR=="A")]="2"
 risultato[which(I1_18_19$FTR=="D")]="X"
 risultato[which(I1_18_19$FTR=="H")]="1"

 df2<-I1_18_19[,which(colnames(I1_18_19) %in% colnames(I1_19_20))]
 df2 <- cbind(df2,risultato)

Creazione colonna "risultato", contenente gli 1,X,2 risultati della corrispondente partita, da aggiungere al dataframe degli anni 2019 e 2020:

 risultato <- rep(NA,nrow(I1_19_20))
 risultato[which(I1_19_20$FTR=="A")]="2"
 risultato[which(I1_19_20$FTR=="D")]="X"
 risultato[which(I1_19_20$FTR=="H")]="1"

 df3<-I1_19_20[,which(colnames(I1_19_20) %in% colnames(I1_18_19))]
 df3 <- cbind(df3,risultato)

Si scelgono per la previsione le seguenti variabili contenenti le probabilità di scommessa 1,X,2 sulle partite fatte dai bookmakers:

B365H = Bet365 probabilità di vittoria in casa
B365D = Bet365 probabilità di pareggio
B365A = Bet365 probabilità di vittoria in trasferta
BSH = probabilità di vittoria in casa Blue Square
BSD = probabilità di pareggio Blue Square
BSA = probabilità di vittoria in trasferta Blue Square
BWH = Bet&Win vittoria in casa
BWD = Bet&Win pareggio
BWA = Bet&Win probabilità di vincere in trasferta
GBH = probabilità di vittoria in casa di Gamebookers
GBD = Gamebookers probabilità di pareggio
GBA = Le probabilità di vincere in trasferta di Gamebookers
IWH = probabilità di vittoria in casa Interwetten
IWD = probabilità di pareggio Interwetten
IWA = Interwetten in trasferta
LBH = Probabilità di vittoria in casa di Ladbrokes
LBD = Ladbrokes probabilità di pareggio
LBA = Ladbrokes probabilità di vittoria in trasferta
PSH e PH = probabilità di vittoria in casa Pinnacle
PSD e PD = probabilità di pareggio di Pinnacle
PSA e PA = Pinnacle probabilità di vittoria in trasferta
SOH = probabilità di vittoria in casa Sporting Odds
SOD = probabilità di pareggio Sporting Odds
SOA = probabilità di vittoria in trasferta Sporting Odds
SBH = probabilità di vittoria in casa di Sportingbet
SBD = probabilità di pareggio di Sportingbet
SBA = probabilità di vittoria in trasferta Sportingbet
SJH = probabilità di vittoria in casa di Stan James
SJD = probabilità di pareggio di Stan James
SJA = probabilità di vittoria in trasferta di Stan James
SYH = probabilità di vittoria in casa di Stanleybet
SYD = probabilità di pareggio di Stanleybet
SYA = Probabilità di vittoria in trasferta di Stanleybet
VCH = VC probabilità di vincita in casa
VCD = VC probabilità di pareggio
VCA = VC probabilità di vittoria in trasferta
WHH = probabilità di vittoria in casa di William Hill
WHD = probabilità di pareggio di William Hill
WHA = Probabilità di vittoria in trasferta di William Hill

...e si uniscono i 3 dataframes contenenti le probabilità di vincita in casa, pareggio o trasferta negli anni 2017,2018,2019,2020 :

 df1<-rbind(df1,df2)
 df1<-rbind(df1,df3)

 df1 <- df1[,which(colnames(df1) %in%  c("Date","HomeTeam","AwayTeam","B365H","B365D","B365A","BWH","BWD","BWA","IWH","IWD","IWA","PSH","PSD","PSA","WHH","WHD","WHA","VCH","VCD","VCA","risultato" ))]

 head(df1)

Si eliminano dal dataframe df1 le righe contenenti gli eventuali valori mancanti nelle probabilità...

 df1 <- df1[-which(rowSums(is.na(df1))>0),]

Parte 2 : Domanda di ricerca

Di prescelte partite future di serie A in Italia il risultato sarà 1,X o 2 tramite l'intelligenza artificiale?

Parte 3 : Modellizzazione e Previsione

Si suddivide il dataset df1 in un training set costituito dal 90% delle partite e in un testing set costituito dal rimanente 10% di partite e come predictors si scelgono le probabilità indicate dai vari bookmakers escludendo data della partita e nomi delle squadre in casa e trasferta. La variabile da predire è "risultato" .

 n <-nrow(df1)
 training <- df1[1:round(n*0.9),c(4:22)]
 testing <- df1[round(n*0.9):n,c(4:22)]
    
 model <-  train( risultato ~ .,data=training, method="rf", verbose=FALSE )

 p1 <- predict(model,newdata = training)
 print(confusionMatrix(p1,training$risultato)) 

 p1 <- predict(model,newdata = testing)
 print(confusionMatrix(p1,testing$risultato))

Confusion Matrix and Statistics of training set:

         Reference
Prediction   1   2   X
        1  370   0   0
        2    0 272   0
        X    0   0 211

Overall Statistics
                                    
              Accuracy : 1          
                95% CI : (0.9957, 1)
   No Information Rate : 0.4338     
   P-Value [Acc > NIR] : < 2.2e-16  
                                    
                 Kappa : 1          
                                    
Mcnemar's Test P-Value : NA

Statistics by Class:

                        Class: 1 Class: 2 Class: X
Sensitivity            1.0000   1.0000   1.0000
Specificity            1.0000   1.0000   1.0000
Pos Pred Value         1.0000   1.0000   1.0000
Neg Pred Value         1.0000   1.0000   1.0000
Prevalence             0.4338   0.3189   0.2474
Detection Rate         0.4338   0.3189   0.2474
Detection Prevalence   0.4338   0.3189   0.2474
Balanced Accuracy      1.0000   1.0000   1.0000

Confusion Matrix and Statistics of the testing set:

         Reference
Prediction  1  2  X
        1  27 12  9
        2   5 18  6
        X   5  7  7

Overall Statistics
                                         
              Accuracy : 0.5417          
                95% CI : (0.4369, 0.6438)
   No Information Rate : 0.3854          
   P-Value [Acc > NIR] : 0.001359        
                                         
                 Kappa : 0.29            
                                         
Mcnemar's Test P-Value : 0.250645

Statistics by Class:

                    Class: 1 Class: 2 Class: X
Sensitivity            0.7297   0.4865  0.31818
Specificity            0.6441   0.8136  0.83784
Pos Pred Value         0.5625   0.6207  0.36842
Neg Pred Value         0.7917   0.7164  0.80519
Prevalence             0.3854   0.3854  0.22917
Detection Rate         0.2812   0.1875  0.07292
Detection Prevalence   0.5000   0.3021  0.19792
Balanced Accuracy      0.6869   0.6500  0.57801

Parte 4: Conclusioni

Utilizzando quindi l'algoritmo Random Forest l'accuratezza della previsione sul training set è del 100%, mentre sul testing set è solo del 54,17% e quindi in pratica partecipare alle scommesse sportive utilizzando il machine learning è approssimativamente come giocare sul rosso e il nero alla Roulette...

TENNIS

Caricamento librerie

library(dplyr)
library(ggplot2)
library(h2o)
library(caret)
library(stringr)

Parte 1 : Dati

I dati scaricabili da qui : https://github.com/JeffSackmann/tennis_atp contengono variabili di tutte le partite di tennis ATP giocate dal 1968 in poi . Le variabili che si prendono in considerazione per la previsione del vincitore o del perdente sono :

best_of - il numero massimo di set giocati
draw_size - la dimensione del disegno
match_num - numero partita in un determinato torneo
round: il round del torneo a cui appartiene una partita
surface - superficie in cui si gioca la partita
tourney_id - id del torneo
tourney_level - livello del torneo

'G' = Grande Slam 'M' = Master 1000s 'A' = altri eventi a livello di tour 'C' = Sfidanti 'S' = Satelliti/ITF 'F' = finali del tour e altri eventi di fine stagione 'D' = Coppa Davis

loser_age - età del giocatore perdente
loser_entry - Come è entrato il giocatore perdente nei tornei?

WC - Carattere jolly D - Qualificazione LL - Perdente fortunato PR - Classifica protetta SE - Esenzione speciale ALT - Giocatore alternativo

loser_hand - mano del giocatore perdente, destra o sinistra
loser_ht - l'altezza del giocatore perdente
loser_id - id del giocatore perdente
loser_ioc - il paese di origine del giocatore perdente
loser_rank - ranking del giocatore perdente
loser_seed - semi del giocatore perdente
winner_age - età del giocatore vincente
winner_entry - Come è entrato il giocatore vincente nei tornei?

WC - Carattere jolly D - Qualificazione LL - Perdente fortunato PR - Classifica protetta SE - Esenzione speciale ALT - Giocatore alternativo

winner_hand - mano del giocatore vincente, destra o sinistra
winner_ht - l'altezza del giocatore vincente
winner_id - id del giocatore vincente
winner_ioc - il paese di origine del giocatore vincente
winner_rank - ranking del giocatore vincente
winner_seed - semi del giocatore vincente

Caricamento dati:

df <- read.csv("ATP.csv")

Parte 2 : Domanda di ricerca

Chi sarà il vincitore o il perdente in una partita di tennis tramite l'intelligenza artificiale ?

Parte 3 : Modellizzazione e Previsione

Si creano 2 nuove variabili: mese e anno:

df$year<- as.integer(str_sub(df$tourney_date, start = 1,end = 4))
df$month <-as.integer(str_sub(df$tourney_date, start = 5,end = 6))

Si scelgono le variabili dal dataset sui cui fare l'addestramento del modello:

df <- df[, c(
  'best_of',
  'draw_size',
  'loser_age',
  'loser_entry',
  'loser_hand',
  'loser_ht',
  'loser_id',
  'loser_ioc',
  'loser_rank',
  'loser_seed',
  'match_num',
  'round',
  'surface',
  'tourney_id',
  'tourney_level',
  'winner_age',
  'winner_entry',
  'winner_hand',
  'winner_ht',
  'winner_id',
  'winner_ioc',
  'winner_rank',
  'winner_seed',
  'year',
  'month'
)]

Si rinominano le variabili relative a loser e winner:

colnames(df)[3:10] <- c(
  "first_age",
  "first_entry",
  "first_hand",
  "first_ht",
  "first_id",
  "first_ioc",
  "first_rank",
  "first_seed"
)

colnames(df)[16:23] <- c(
  "second_age",
  "second_entry",
  "second_hand",
  "second_ht",
  "second_id",
  "second_ioc",
  "second_rank",
  "second_seed"
)

Si crea una copia del dataset df in df1 e si scambia il primo con il secondo giocatore:

df1 <- df
df1[, c(
  "first_age",
  "first_entry",
  "first_hand",
  "first_ht",
  "first_id",
  "first_ioc",
  "first_rank",
  "first_seed",
  "second_age",
  "second_entry",
  "second_hand",
  "second_ht",
  "second_id",
  "second_ioc",
  "second_rank",
  "second_seed"
)] <- df1[, c(
  "second_age",
  "second_entry",
  "second_hand",
  "second_ht",
  "second_id",
  "second_ioc",
  "second_rank",
  "second_seed",
  "first_age",
  "first_entry",
  "first_hand",
  "first_ht",
  "first_id",
  "first_ioc",
  "first_rank",
  "first_seed"
)]

Si crea la variabile label da predire . label assume il valore 0 nel dataset df in cui second player vince e assume il valore 1 nel dataset df1 in cui first player vince e si concatenano i 2 due dataset:

df$label=0
df1$label=1
df <- rbind(df,df1)

Si divide il dataset df in un training set fatto dal 75% delle osservazioni e su cui si addestra il modello ed il rimanente 25% costituisce il testing set su cui verrà testato il modello :

df$label <- as.factor(df$label)
trainIndex <- createDataPartition(df$label,p=0.75, list = FALSE)
training <- df[trainIndex,]
testing <- df[-trainIndex,]

Si inizializza la libreria h2o necessaria per automatizzare il machine learning:

h2o.init()

Connection successful!
R is connected to the H2O cluster: 
   H2O cluster uptime:         1 hours 20 minutes 
   H2O cluster timezone:       Europe/Rome 
   H2O data parsing timezone:  UTC 
   H2O cluster version:        3.38.0.1 
   H2O cluster version age:    1 month and 1 day  
   H2O cluster name:           H2O_started_from_R_gian_yty236 
   H2O cluster total nodes:    1 
   H2O cluster total memory:   1.06 GB 
   H2O cluster total cores:    2 
   H2O cluster allowed cores:  2 
   H2O cluster healthy:        TRUE 
   H2O Connection ip:          localhost 
   H2O Connection port:        54321 
   H2O Connection proxy:       NA 
   H2O Internal Security:      FALSE 
   R Version:                  R version 4.2.1 (2022-06-23)

Si addestra il modello :

df_hf <- as.h2o(training)
y <- "label"
x <- names(training)[1:25]

aml <- h2o.automl(x = x, y = y,
                  training_frame = df_hf,
                  max_runtime_secs =300)

Si ottengono i seguenti modelli per cui il migliore risulta : StackedEnsemble_BestOfFamily_4_AutoML_3_20221020_193936 con un auc=74,21%

lb <- aml@leaderboard
lb

model_id       auc   logloss     aucpr mean_per_class_error      rmse       mse
1 StackedEnsemble_BestOfFamily_4_AutoML_3_20221020_193936 0.7421346 0.5959886 0.7396699            0.3577591 0.4533024 0.2054831
2    StackedEnsemble_AllModels_2_AutoML_3_20221020_193936 0.7420115 0.5958908 0.7398776            0.3588214 0.4532841 0.2054665
3    StackedEnsemble_AllModels_1_AutoML_3_20221020_193936 0.7419540 0.5958249 0.7400070            0.3604438 0.4532571 0.2054420
4 StackedEnsemble_BestOfFamily_2_AutoML_3_20221020_193936 0.7411001 0.5967041 0.7383371            0.3551206 0.4536377 0.2057871
5 StackedEnsemble_BestOfFamily_3_AutoML_3_20221020_193936 0.7407722 0.5971972 0.7378754            0.3517726 0.4538422 0.2059727
6                          GBM_2_AutoML_3_20221020_193936 0.7405898 0.5974683 0.7373835            0.3475135 0.4539269 0.2060496

Si prova il modello sul testing set ottenendo la matrice di confusione e un'accuracy del 64,07% :

test <- as.h2o(testing)
model <- aml@leader
p1 = h2o.predict(model, newdata=test)
confusionMatrix(df2$predict,testing$label)

Confusion Matrix and Statistics
          Reference
Prediction     0     1
         0 17099  5159
         1 25323 37263
                                        
              Accuracy : 0.6407         
                95% CI : (0.6375, 0.644)
   No Information Rate : 0.5            
   P-Value [Acc > NIR] : < 2.2e-16      
                 Kappa : 0.2815         
Mcnemar's Test P-Value : < 2.2e-16      
           Sensitivity : 0.4031         
           Specificity : 0.8784         
        Pos Pred Value : 0.7682         
        Neg Pred Value : 0.5954         
            Prevalence : 0.5000         
        Detection Rate : 0.2015         
  Detection Prevalence : 0.2623         
     Balanced Accuracy : 0.6407

Parte 4 : Previsioni con Python

Di seguito si utilizza il codice contenuto in questo Notebook : https://www.kaggle.com/code/alexisbcook/pipelines rilasciato con licenza Apache 2.0 .

import pandas as pd
from sklearn.model_selection import train_test_split

# Caricamento dei dati
data = pd.read_csv('tennis.csv')

# Separo la variabile da predire label dai predictors
y = data.label
X = data.drop(['label'], axis=1)

# Divido i dati in training e validation subsets, il primo con il 75% delle partite e il secondo con il 25%
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size=0.75, test_size=0.25,random_state=0)

# Seleziono le colonne con valori categoriali in numero minore di 10
categorical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and 
                        X_train_full[cname].dtype == "object"]

# Seleziono le colonne numeriche
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]

# Mantengo soltanto le colonne selezionate
my_cols = categorical_cols + numerical_cols
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy()

Le colonne numeriche e categoriche nel dataset che hanno valori mancanti NA vengono trasformate con valori approssimativi nei NA tramite SimpleImputer, mentre le variabili categoriche vengono trasformate in numeriche tramite OneHotEncoder :

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

# Preprocessing per i dati numerici
numerical_transformer = SimpleImputer(strategy='constant')

# Preprocessing per i dati categoriali
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])


preprocessor = ColumnTransformer(
    transformers=[
        ('num', numerical_transformer, numerical_cols),
        ('cat', categorical_transformer, categorical_cols)
    ])

Per la previsione utilizzo l'algoritmo XGBoost (Extreme Gradient Boosting) e addestro il modello sul training set dopo avere preprocessato i dati con il preprocessor precedentemente creato. Infine prevedo i dati sul validation set.

from xgboost import XGBClassifier

model = XGBClassifier(learning_rate=0.05)

my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                              ('model', model)
                             ])

# addestro il modello 
my_pipeline.fit(X_train, y_train)

# ottengo le previsioni sul validation set
preds = my_pipeline.predict(X_valid)

Sul validation set ottengo un'accuracy del 68% :

from sklearn.metrics import classification_report
 
print(classification_report(y_valid, preds))

             precision    recall  f1-score   support

           0       0.68      0.67      0.68     42670
           1       0.67      0.68      0.67     42175
    accuracy                           0.68     84845
   macro avg       0.68      0.68      0.68     84845
weighted avg       0.68      0.68      0.68     84845

Parte 5: Conclusioni

Rispetto al calcio, nel tennis si ottiene un'accuracy maggiore e quindi una previsione migliore ma non sufficiente per considerare le previsioni su scommesse sportive tramite machine learning un buon investimento.

FORMULA 1 (Gran Premi)

Parte 1: Dati

Dal seguente link: http://ergast.com/mrd/ è possibile scaricare i dataset dei Gran Premi di Formula 1 con dati dal 1950 al 2023 e predire tramite algoritmi di machine learning il pilota vincente con un'Accuracy del 99% sul testing set.

Caricamento dati:

import pandas as pd

# Tabella riassuntiva dei risultati:
result_df = pd.read_csv('results.csv')
# Stato del pilota:
stats_df = pd.read_csv('status.csv')
# Piloti :
drivers_df = pd.read_csv('drivers.csv')
# Gran Premi:
races_df = pd.read_csv('races.csv')
# Case automobilistiche :
constructor_df = pd.read_csv('constructors.csv')
driver_standings_df = pd.read_csv('driver_standings.csv')

# unisco i datasets in un singolo dataset df :

con1 = pd.merge(result_df, races_df, on ='raceId')
con2 = pd.merge(con1, drivers_df, on = 'driverId')
con3 = pd.merge(con2, driver_standings_df, on = 'driverId')
con4 = pd.merge(con3, constructor_df, on ='constructorId')
df = pd.merge(con4, stats_df, on ='statusId')
df.head()

# Le variabili sono le seguenti: 
df.info()

Come si vede, ci sono 3.475.793 righe e 37 colonne nel dataset df :

<class 'pandas.core.frame.DataFrame'>
Int64Index: 3475793 entries, 0 to 3475792
Data columns (total 37 columns):
 #   Column             Dtype  
---  ------             -----  
0   resultId           int64  
1   raceId_x           int64  
2   driverId           int64  
3   constructorId      int64  
4   number_x           object 
5   grid               int64  
6   position_x         object 
7   positionText_x     object 
8   positionOrder      int64  
9   points_x           float64
10  laps               int64  
11  time               object 
12  milliseconds       object 
13  fastestLap         object 
14  rank               object 
15  fastestLapTime     object 
16  fastestLapSpeed    object 
17  statusId           int64  
18  driverRef          object 
19  number_y           object 
20  code               object 
21  forename           object 
22  surname            object 
23  dob                object 
24  nationality_x      object 
25  url_x              object 
26  driverStandingsId  int64  
27  raceId_y           int64  
28  points_y           float64
29  position_y         int64  
30  positionText_y     object 
31  wins               int64  
32  constructorRef     object 
33  name               object 
34  nationality_y      object 
35  url_y              object 
36  status             object 
dtypes: float64(2), int64(12), object(23)
memory usage: 1007.7+ MB

# cancello alcune variabili : 

df = df.drop(['url_y','url_x','position_x','fastestLapTime','positionText_x','driverRef',
              'constructorRef','nationality_y','positionText_y','raceId_y','points_y'],1)
              
# Creo la variabile driver_name col nome e cognome del pilota, che verrà prevista dall'algoritmo:

df['driver_name'] = df['forename']+' '+df['surname']
df = df.drop(['forename','surname'],1)

# converto alcune variabili di tipo object in variabili numeriche :
l = ['number_x','milliseconds','fastestLap','rank','fastestLapSpeed','number_y']
for i in l:
   df[i] = pd.to_numeric(df[i],errors='coerce')

Considero soltanto i piloti in stato finished, cioè quelli che hanno percorso almeno il 90% dei giri del Gran Premio, quindi su 60 giri ne hanno fatti almeno 54. In tal modo riduco il dataset a 1.320.987 righe:

df = df[df['status'] == 'Finished']
df.shape

(1320987, 42)

Parte 2: Previsioni

from sklearn.model_selection import train_test_split

# Separo la variabile da predire driver_name dai predictors
y = df.driver_name
X = df.drop(['driver_name'], axis=1)

# Divido i dati in training e validation subsets, il primo con il 70% delle partite e il secondo con il 30%

X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, test_size=0.3,
                                                                random_state=0)

# Seleziono le colonne con valori categoriali in numero minore di 10
categorical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and 
                        X_train_full[cname].dtype == "object"]

# Seleziono le colonne numeriche
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]

# Mantengo soltanto le colonne selezionate
my_cols = categorical_cols + numerical_cols
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy()

Le colonne numeriche e categoriche nel dataset che hanno valori mancanti NA vengono trasformate con valori approssimativi nei NA tramite SimpleImputer, mentre le variabili categoriche vengono trasformate in numeriche tramite LabelEncoder :

from sklearn.preprocessing import LabelEncoder
from sklearn.impute import SimpleImputer

label_encoder = LabelEncoder()
for i in categorical_cols:
    X_train[i]=label_encoder.fit_transform(X_train[i])
    X_valid[i] = label_encoder.fit_transform(X_valid[i])

my_imputer = SimpleImputer()
X_train[numerical_cols] = my_imputer.fit_transform(X_train[numerical_cols])
X_valid[numerical_cols] = my_imputer.transform(X_valid[numerical_cols])

Per la previsione utilizzo l'algoritmo KNeighbors (il più semplice degli algoritmi di machine learning) e addestro il modello sul training set. Infine prevedo i dati sul validation set:

from sklearn.neighbors import KNeighborsClassifier

model= KNeighborsClassifier()

model.fit(X_train,y_train)
ypred = model.predict(X_valid)

Sul validation set ottengo un'accuracy del 99% :

from sklearn.metrics import classification_report
 
print(classification_report(y_valid, preds))

     	      accuracy                           0.99    396297
             macro avg       0.99      0.98      0.98    396297
          weighted avg       0.99      0.99      0.99    396297

Parte 3: Conclusioni

Sebbene l'accuracy previsionale sia del 99%, il modello non prevede eventuali incidenti, guasti o cattive condizioni climatiche quindi in realtà l'accuratezza è minore...

Applicazioni pratiche di machine learning/Previsioni su scommesse sportive

Indice

CALCIO

Caricamento librerie

Parte 1: Dati

Parte 2 : Domanda di ricerca

Parte 3 : Modellizzazione e Previsione

Parte 4: Conclusioni

TENNIS

Caricamento librerie

Parte 1 : Dati

Parte 2 : Domanda di ricerca

Parte 3 : Modellizzazione e Previsione

Parte 4 : Previsioni con Python

Parte 5: Conclusioni

FORMULA 1 (Gran Premi)

Parte 1: Dati

Parte 2: Previsioni

Parte 3: Conclusioni