Algoritmi di apprendimento automatico comunemente usati (con codici Python e R)

Nota: Questo articolo è stato originariamente pubblicato il 10 agosto 2015 e aggiornato il 9 settembre 2017

Panoramica

• Focus principale sugli algoritmi di apprendimento automatico comunemente usati
• Algoritmi trattati: regressione lineare, regressione logistica, Naive Bayes, kNN, foresta casuale, ecc.
• Imparare sia la teoria che l’implementazione di questi algoritmi in R e python

Introduzione

Le auto a guida autonoma e i robot di Google ricevono molta stampa, ma il vero futuro dell’azienda è nel machine learning, la tecnologia che permette ai computer di diventare più intelligenti e più personali.

– Eric Schmidt (Presidente di Google)

Stiamo probabilmente vivendo il periodo più significativo della storia umana. Il periodo in cui l’informatica si è spostata dai grandi mainframe ai PC al cloud. Ma ciò che lo rende determinante non è ciò che è successo, ma ciò che ci aspetta negli anni a venire.

Ciò che rende questo periodo eccitante e coinvolgente per uno come me è la democratizzazione dei vari strumenti e tecniche, che ha seguito la spinta dell’informatica. Benvenuti nel mondo della scienza dei dati!

Oggi, come scienziato dei dati, posso costruire macchine che sminuzzano i dati con algoritmi complessi per pochi dollari all’ora. Ma arrivare qui non è stato facile! Ho avuto i miei giorni e le mie notti buie.

Sei un principiante alla ricerca di un posto dove iniziare il tuo viaggio nella scienza dei dati? Ti presentiamo due corsi completi, pieni di conoscenza e apprendimento della scienza dei dati, curati proprio per te per imparare la scienza dei dati (usando Python) da zero:

• Introduzione alla scienza dei dati
• Certificato AI & ML Blackbelt+ Program

Chi può beneficiare maggiormente di questa guida?

Quella che sto dando oggi è probabilmente la guida più preziosa che abbia mai creato.

L’idea dietro la creazione di questa guida è quella di semplificare il viaggio degli aspiranti scienziati di dati e degli appassionati di apprendimento automatico in tutto il mondo. Attraverso questa guida, vi permetterò di lavorare su problemi di apprendimento automatico e guadagnare dall’esperienza. Sto fornendo una comprensione di alto livello di vari algoritmi di apprendimento automatico insieme a R & codici Python per eseguirli. Questi dovrebbero essere sufficienti per sporcarsi le mani.

Ho deliberatamente saltato le statistiche dietro queste tecniche, poiché non è necessario capirle all’inizio. Quindi, se state cercando la comprensione statistica di questi algoritmi, dovreste cercare altrove. Ma, se stai cercando di attrezzarti per iniziare a costruire un progetto di apprendimento automatico, ti aspetta una sorpresa.

In generale, ci sono 3 tipi di algoritmi di apprendimento automatico

Apprendimento supervisionato

Come funziona: Questo algoritmo consiste in una variabile obiettivo/risultato (o variabile dipendente) che deve essere prevista da un dato insieme di predittori (variabili indipendenti). Utilizzando questo insieme di variabili, si genera una funzione che mappa gli input agli output desiderati. Il processo di formazione continua fino a quando il modello raggiunge un livello desiderato di accuratezza sui dati di formazione. Esempi di apprendimento supervisionato: Regressione, Albero delle decisioni, Foresta casuale, KNN, Regressione logistica ecc.

Apprendimento non supervisionato

Come funziona: In questo algoritmo, non abbiamo alcuna variabile obiettivo o risultato da prevedere/stimare. Viene utilizzato per raggruppare la popolazione in diversi gruppi, che è ampiamente utilizzato per segmentare i clienti in diversi gruppi per un intervento specifico. Esempi di apprendimento non supervisionato: Algoritmo Apriori, K-means.

Reinforcement Learning:

Come funziona: Utilizzando questo algoritmo, la macchina viene addestrata a prendere decisioni specifiche. Funziona in questo modo: la macchina è esposta a un ambiente in cui si allena continuamente usando prove ed errori. Questa macchina impara dall’esperienza passata e cerca di catturare la migliore conoscenza possibile per prendere decisioni aziendali accurate. Esempio di apprendimento per rinforzo: Markov Decision Process

Lista dei comuni algoritmi di apprendimento automatico

Questa è la lista degli algoritmi di apprendimento automatico comunemente usati. Questi algoritmi possono essere applicati a quasi tutti i problemi di dati:

1. Regressione lineare
2. Regressione logistica
3. Albero di decisione
4. SVM
5. Naive Bayes
6. kNN
7. K-Means
8. Random Forest
9. Algoritmi di riduzione della dimensionalità
10. Algoritmi di boosting radiante
    1. GBM
    2. XGBoost
    3. LightGBM
    4. CatBoost

Regressione lineare

È usato per stimare valori reali (costo delle case, numero di chiamate, vendite totali ecc.) sulla base di variabili continue. Qui, stabiliamo la relazione tra le variabili indipendenti e dipendenti adattando una linea migliore. Questa linea migliore è conosciuta come linea di regressione e rappresentata da un’equazione lineare Y= a *X + b.

Il modo migliore per capire la regressione lineare è rivivere questa esperienza dell’infanzia. Diciamo che chiedete a un bambino di quinta elementare di disporre le persone della sua classe in ordine crescente di peso, senza chiedere loro il peso! Cosa pensate che farà il bambino? Lui/lei probabilmente guarderà (analizzerà visivamente) l’altezza e la corporatura delle persone e le sistemerà usando una combinazione di questi parametri visibili. Questa è la regressione lineare nella vita reale! Il bambino ha effettivamente capito che l’altezza e la corporatura sarebbero correlate al peso da una relazione, che assomiglia all’equazione di cui sopra.

In questa equazione:

• Y – Variabile dipendente
• a – Pendenza
• X – Variabile indipendente
• b – Intercetta

Questi coefficienti a e b sono derivati in base alla minimizzazione della somma della differenza quadratica della distanza tra i punti dati e la linea di regressione.

Guardate l’esempio seguente. Qui abbiamo identificato la linea di miglior adattamento con equazione lineare y=0.2811x+13.9. Ora, usando questa equazione, possiamo trovare il peso, conoscendo l’altezza di una persona.

La regressione lineare è principalmente di due tipi: Regressione lineare semplice e Regressione lineare multipla. La Regressione Lineare Semplice è caratterizzata da una sola variabile indipendente. E la Regressione Lineare Multipla (come suggerisce il nome) è caratterizzata da più (più di 1) variabili indipendenti. Mentre si trova la linea migliore, è possibile adattare una regressione polinomiale o curvilinea. E queste sono conosciute come regressione polinomiale o curvilinea.

Ecco una finestra di codifica per provare la vostra mano e costruire il vostro modello di regressione lineare in Python:

R Code

#Load Train and Test datasets#Identify feature and response variable(s) and values must be numeric and numpy arraysx_train <- input_variables_values_training_datasetsy_train <- target_variables_values_training_datasetsx_test <- input_variables_values_test_datasetsx <- cbind(x_train,y_train)# Train the model using the training sets and check scorelinear <- lm(y_train ~ ., data = x)summary(linear)#Predict Outputpredicted= predict(linear,x_test)

Regressione logistica

Non fatevi confondere dal suo nome! È un algoritmo di classificazione e non di regressione. È usato per stimare valori discreti (valori binari come 0/1, sì/no, vero/falso) basati su un dato insieme di variabili indipendenti. In parole semplici, predice la probabilità del verificarsi di un evento adattando i dati a una funzione logit. Quindi, è anche conosciuta come regressione logit. Poiché predice la probabilità, i suoi valori di uscita sono compresi tra 0 e 1 (come previsto).

Ancora una volta, cerchiamo di capire questo attraverso un semplice esempio.

Diciamo che il vostro amico vi dà un puzzle da risolvere. Ci sono solo 2 scenari di risultato – o lo risolvi o non lo fai. Ora immagina che ti venga data una vasta gamma di puzzle / quiz nel tentativo di capire in quali materie sei bravo. Il risultato di questo studio sarebbe qualcosa del genere – se ti viene dato un problema di trignometria basato sulla decima classe, hai il 70% di probabilità di risolverlo. D’altra parte, se si tratta di una domanda di storia di quinta elementare, la probabilità di ottenere una risposta è solo del 30%. Questo è ciò che la regressione logistica vi fornisce.

Venendo alla matematica, le probabilità logiche del risultato sono modellate come una combinazione lineare delle variabili predittive.

odds= p/ (1-p) = probabilità di accadimento dell'evento / probabilità di non accadimento dell'eventorenceln(odds) = ln(p/(1-p))logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

Sopra, p è la probabilità di presenza della caratteristica di interesse. Sceglie i parametri che massimizzano la probabilità di osservare i valori del campione piuttosto che minimizzare la somma degli errori al quadrato (come nella regressione ordinaria).

Ora, vi chiederete, perché prendere un log? Per semplicità, diciamo solo che questo è uno dei migliori modi matematici per replicare una funzione di passo. Potrei entrare in maggiori dettagli, ma questo non rientra nello scopo di questo articolo.

Costruisci il tuo modello di regressione logistica in Python qui e controlla la precisione:

Codice R

x <- cbind(x_train,y_train)# Train the model using the training sets and check scorelogistic <- glm(y_train ~ ., data = x,family='binomial')summary(logistic)#Predict Outputpredicted= predict(logistic,x_test)

Inoltre.

Ci sono molti passi diversi che potrebbero essere provati per migliorare il modello:

• includere termini di interazione
• rimuovere caratteristiche
• tecniche di regolarizzazione
• utilizzare un modello non lineare

Albero di Decisione

Questo è uno dei miei algoritmi preferiti e lo uso abbastanza spesso. È un tipo di algoritmo di apprendimento supervisionato che viene utilizzato principalmente per problemi di classificazione. Sorprendentemente, funziona sia per variabili dipendenti categoriche che continue. In questo algoritmo, dividiamo la popolazione in due o più insiemi omogenei. Questo viene fatto in base agli attributi/ variabili indipendenti più significativi per fare gruppi il più possibile distinti. Per maggiori dettagli, puoi leggere: Decision Tree Simplified.

fonte: statsexchange

Nell’immagine sopra, si può vedere che la popolazione è classificata in quattro gruppi diversi in base a più attributi per identificare ‘se giocheranno o no’. Per dividere la popolazione in diversi gruppi eterogenei, utilizza varie tecniche come Gini, Information Gain, Chi-quadrato, entropia.

Il modo migliore per capire come funziona l’albero decisionale, è giocare a Jezzball – un classico gioco di Microsoft (immagine sotto). Essenzialmente, avete una stanza con delle pareti mobili e dovete creare delle pareti in modo tale che l’area massima venga liberata senza le palle.

Quindi, ogni volta che dividete la stanza con una parete, state cercando di creare 2 popolazioni diverse nella stessa stanza. Gli alberi decisionali funzionano in modo molto simile, dividendo una popolazione in gruppi il più possibile diversi.

Altro: Versione semplificata degli algoritmi degli alberi decisionali

Ci sporchiamo le mani e codifichiamo il nostro albero decisionale in Python!

R Code

library(rpart)x <- cbind(x_train,y_train)# grow tree fit <- rpart(y_train ~ ., data = x,method="class")summary(fit)#Predict Output predicted= predict(fit,x_test)

SVM (Support Vector Machine)

È un metodo di classificazione. In questo algoritmo, tracciamo ogni dato come un punto nello spazio n-dimensionale (dove n è il numero di caratteristiche che avete) con il valore di ogni caratteristica che è il valore di una particolare coordinata.

Per esempio, se avessimo solo due caratteristiche come l’altezza e la lunghezza dei capelli di un individuo, prima tracceremo queste due variabili in uno spazio bidimensionale dove ogni punto ha due coordinate (queste coordinate sono conosciute come vettori di supporto)

Ora, troveremo una linea che divide i dati tra i due gruppi di dati diversamente classificati. Questa sarà la linea tale che le distanze dal punto più vicino in ciascuno dei due gruppi saranno le più lontane.

Nell’esempio mostrato sopra, la linea che divide i dati in due gruppi diversamente classificati è la linea nera, poiché i due punti più vicini sono i più lontani dalla linea. Questa linea è il nostro classificatore. Quindi, a seconda di dove i dati di test si posizionano su entrambi i lati della linea, ecco come possiamo classificare i nuovi dati.

Altro: Versione semplificata della Support Vector Machine

Pensate a questo algoritmo come a un gioco di JezzBall nello spazio n-dimensionale. Le modifiche nel gioco sono:

• È possibile disegnare linee/piani a qualsiasi angolo (piuttosto che solo orizzontale o verticale come nel gioco classico)
• L’obiettivo del gioco è quello di segregare palle di diversi colori in diverse stanze.
• E le palle non si muovono.

Prova a progettare un modello SVM in Python attraverso questa finestra di codifica:

R Code

library(e1071)x <- cbind(x_train,y_train)# Fitting modelfit <-svm(y_train ~ ., data = x)summary(fit)#Predict Output predicted= predict(fit,x_test)

Naive Bayes

È una tecnica di classificazione basata sul teorema di Bayes con un presupposto di indipendenza tra predittori. In termini semplici, un classificatore di Naive Bayes assume che la presenza di una particolare caratteristica in una classe non sia correlata alla presenza di qualsiasi altra caratteristica. Per esempio, un frutto può essere considerato una mela se è rosso, rotondo e di circa 3 pollici di diametro. Anche se queste caratteristiche dipendono l’una dall’altra o dall’esistenza di altre caratteristiche, un classificatore di Bayes ingenuo considererebbe tutte queste proprietà per contribuire indipendentemente alla probabilità che questo frutto sia una mela.

Il modello bayesiano ingenuo è facile da costruire e particolarmente utile per serie di dati molto grandi. Oltre alla semplicità, Naive Bayes è noto per superare anche metodi di classificazione altamente sofisticati.

Il teorema di Bayes fornisce un modo per calcolare la probabilità posteriore P(c|x) da P(c), P(x) e P(x|c). Guardate l’equazione qui sotto:

Qui,

• P(c|x) è la probabilità posteriore della classe (target) dato il predittore (attributo).
• P(c) è la probabilità anteriore della classe.
• P(x|c) è la probabilità che è la probabilità del predittore data la classe.
• P(x) è la probabilità a priori del predittore.

Esempio: Cerchiamo di capire usando un esempio. Di seguito ho un set di dati di formazione del tempo e la corrispondente variabile target ‘Play’. Ora, abbiamo bisogno di classificare se i giocatori giocheranno o meno in base alle condizioni meteorologiche.

Step 1: Convertire il set di dati in una tabella di frequenza

Step 2: Creare una tabella di probabilità trovando le probabilità come Overcast probability = 0.29 e probability of playing è 0.64.

Step 3: Ora, usare l’equazione Naive Bayesian per calcolare la probabilità posteriore per ogni classe. La classe con la probabilità posteriore più alta è il risultato della predizione.

Problema: I giocatori pagheranno se il tempo è soleggiato, questa affermazione è corretta?

Possiamo risolverla usando il metodo sopra discusso, quindi P(Sì | Soleggiato) = P( Soleggiato | Sì) * P(Sì) / P (Soleggiato)

Qui abbiamo P (Soleggiato | Sì) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P( Yes)= 9/14 = 0.64

Ora, P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60, che ha una probabilità più alta.

Naive Bayes usa un metodo simile per predire la probabilità di classi diverse in base a vari attributi. Questo algoritmo è usato principalmente nella classificazione del testo e con problemi che hanno classi multiple.

Codifica un modello di classificazione di Naive Bayes in Python:

R Code

library(e1071)x <- cbind(x_train,y_train)# Fitting modelfit <-naiveBayes(y_train ~ ., data = x)summary(fit)#Predict Output predicted= predict(fit,x_test)

kNN (k- Nearest Neighbors)

Può essere usato sia per problemi di classificazione che di regressione. Tuttavia, è più utilizzato nei problemi di classificazione nell’industria. K nearest neighbors è un semplice algoritmo che memorizza tutti i casi disponibili e classifica i nuovi casi con un voto di maggioranza dei suoi k vicini. Il caso che viene assegnato alla classe è il più comune tra i suoi K vicini più vicini misurato da una funzione di distanza.

Queste funzioni di distanza possono essere la distanza euclidea, Manhattan, Minkowski e Hamming. Le prime tre funzioni sono usate per le funzioni continue e la quarta (Hamming) per le variabili categoriche. Se K = 1, allora il caso viene semplicemente assegnato alla classe del suo vicino più vicino. A volte, la scelta di K risulta essere una sfida durante l’esecuzione della modellazione kNN.

Altro: Introduzione a k-nearest neighbors : Semplificato.

KNN può essere facilmente mappato nella nostra vita reale. Se volete conoscere una persona, di cui non avete informazioni, potreste scoprire i suoi amici intimi e i circoli in cui si muove e avere accesso alle sue informazioni!

Cose da considerare prima di scegliere kNN:

• KNN è computazionalmente costoso
• Le variabili dovrebbero essere normalizzate altrimenti le variabili di range più alto possono distorcerlo
• Lavora di più sulla fase di pre-elaborazione prima di passare a kNN come un outlier, rimozione del rumore

Codice Python

Codice R

library(knn)x <- cbind(x_train,y_train)# Fitting modelfit <-knn(y_train ~ ., data = x,k=5)summary(fit)#Predict Output predicted= predict(fit,x_test)

K-Means

È un tipo di algoritmo non supervisionato che risolve il problema del clustering. La sua procedura segue un modo semplice e facile per classificare un dato set di dati attraverso un certo numero di cluster (supponiamo k cluster). I punti di dati all’interno di un cluster sono omogenei ed eterogenei ai gruppi di pari.

Ricordate di aver capito le forme dalle macchie di inchiostro? k significa è in qualche modo simile questa attività. Si guarda la forma e la diffusione per decifrare quanti diversi cluster/popolazione sono presenti!

Come K-means forma i cluster:

1. K-means sceglie k numero di punti per ogni cluster conosciuto come centroide.
2. Ogni punto di dati forma un cluster con i centroidi più vicini, cioè k cluster.
3. Trova il centroide di ogni cluster sulla base dei membri del cluster esistenti. Qui abbiamo nuovi centroidi.
4. Dato che abbiamo nuovi centroidi, ripetere i passi 2 e 3. Trovare la distanza più vicina per ogni punto di dati dai nuovi centroidi e associarli ai nuovi k-cluster. Ripetere questo processo fino a quando si verifica la convergenza, cioè i centroidi non cambiano.

Come determinare il valore di K:

In K-means, abbiamo cluster e ogni cluster ha il suo centroide. La somma dei quadrati della differenza tra il centroide e i punti dati all’interno di un cluster costituisce la somma dei valori quadrati per quel cluster. Inoltre, quando la somma dei valori quadrati per tutti i cluster vengono aggiunti, diventa il totale entro la somma dei valori quadrati per la soluzione del cluster.

Sappiamo che all’aumentare del numero di cluster, questo valore continua a diminuire, ma se si traccia il risultato si può vedere che la somma della distanza quadratica diminuisce bruscamente fino ad un certo valore di k, e poi molto più lentamente. Qui, possiamo trovare il numero ottimale di cluster.

Codice Python

Codice R

library(cluster)fit <- kmeans(X, 3) # 5 cluster solution

Random Forest

Random Forest è un termine commerciale per un insieme di alberi decisionali. In Random Forest, abbiamo un insieme di alberi di decisione (conosciuto come “Forest”). Per classificare un nuovo oggetto in base agli attributi, ogni albero dà una classificazione e diciamo che l’albero “vota” per quella classe. La foresta sceglie la classificazione che ha più voti (su tutti gli alberi della foresta).

Ogni albero viene piantato & coltivato come segue:

1. Se il numero di casi nel training set è N, allora un campione di N casi viene preso a caso ma con sostituzione. Questo campione sarà l’insieme di allenamento per la crescita dell’albero.
2. Se ci sono M variabili di input, viene specificato un numero m<<M tale che ad ogni nodo, m variabili sono selezionate a caso tra le M e la migliore divisione su queste m è usata per dividere il nodo. Il valore di m è mantenuto costante durante la crescita della foresta.
3. Ogni albero viene fatto crescere il più possibile. Non c’è alcuna potatura.

Per maggiori dettagli su questo algoritmo, sul confronto con l’albero decisionale e sulla regolazione dei parametri del modello, vi suggerisco di leggere questi articoli:

1. Introduzione alla foresta casuale – Semplificata

2. Confronto di un modello CART con Random Forest (Parte 1)

3. Confronto un modello Random Forest a un modello CART (Parte 2)

4. Tuning dei parametri del tuo modello Random Forest

Codice Python:

Codice R

library(randomForest)x <- cbind(x_train,y_train)# Fitting modelfit <- randomForest(Species ~ ., x,ntree=500)summary(fit)#Predict Output predicted= predict(fit,x_test)

Algoritmi di riduzione della dimensionalità

Negli ultimi 4-5 anni, c’è stato un aumento esponenziale nell’acquisizione di dati in ogni fase possibile. Le aziende/agenzie governative/organizzazioni di ricerca non solo stanno arrivando con nuove fonti, ma stanno anche catturando i dati in grande dettaglio.

Per esempio: Le società di e-commerce stanno catturando più dettagli sui clienti come i loro dati demografici, la cronologia del web crawling, ciò che gli piace o non gli piace, la cronologia degli acquisti, i feedback e molti altri per dare loro un’attenzione personalizzata più del più vicino negoziante di alimentari.

Come scienziato dei dati, i dati che ci vengono offerti consistono anche di molte caratteristiche, questo suona bene per costruire un buon modello robusto ma c’è una sfida. Come si fa a identificare una o più variabili altamente significative su 1000 o 2000? In questi casi, l’algoritmo di riduzione della dimensionalità ci aiuta insieme a vari altri algoritmi come Decision Tree, Random Forest, PCA, Factor Analysis, Identify based on correlation matrix, missing value ratio e altri.

Per saperne di più su questi algoritmi, potete leggere “Beginners Guide To Learn Dimension Reduction Techniques”.

Codice Python

Codice R

library(stats)pca <- princomp(train, cor = TRUE)train_reduced <- predict(pca,train)test_reduced <- predict(pca,test)

Algoritmi di boosting radiante

10.1. GBM

GBM è un algoritmo di boosting utilizzato quando abbiamo a che fare con un sacco di dati per fare una previsione con un alto potere di previsione. Il boosting è in realtà un insieme di algoritmi di apprendimento che combina la previsione di diversi stimatori di base al fine di migliorare la robustezza rispetto a un singolo stimatore. Combina più predittori deboli o medi per costruire un predittore forte. Questi algoritmi di boosting funzionano sempre bene nelle competizioni di scienza dei dati come Kaggle, AV Hackathon, CrowdAnalytix.

Altro: Conoscere gli algoritmi di Boosting in dettaglio

Codice Python

Codice R

library(caret)x <- cbind(x_train,y_train)# Fitting modelfitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)predicted= predict(fit,x_test,type= "prob") 

GradientBoostingClassifier e Random Forest sono due diversi classificatori ad albero boosting e spesso la gente chiede la differenza tra questi due algoritmi.

10.2. XGBoost

Un altro classico algoritmo di gradient boosting che è noto per essere la scelta decisiva tra vincere e perdere in alcune competizioni Kaggle.

L’XGBoost ha un immensamente alto potere predittivo che lo rende la scelta migliore per l’accuratezza negli eventi in quanto possiede sia il modello lineare che l’algoritmo di apprendimento ad albero, rendendo l’algoritmo quasi 10 volte più veloce delle tecniche esistenti di gradient booster.

Il supporto include varie funzioni obiettivo, tra cui la regressione, la classificazione e il ranking.

Una delle cose più interessanti di XGBoost è che è anche chiamata una tecnica di boosting regolarizzata. Questo aiuta a ridurre la modellazione dell’overfit e ha un supporto massiccio per una serie di linguaggi come Scala, Java, R, Python, Julia e C++.

Supporta la formazione distribuita e diffusa su molte macchine che comprendono cluster GCE, AWS, Azure e Yarn. XGBoost può anche essere integrato con Spark, Flink e altri sistemi cloud dataflow con una validazione incrociata incorporata ad ogni iterazione del processo di boosting.

Per saperne di più su XGBoost e sulla regolazione dei parametri, visitate https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/.

Codice Python:

R Code:

require(caret)x <- cbind(x_train,y_train)# Fitting modelTrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)OR model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)predicted <- predict(model, x_test)

10.3. LightGBM

LightGBM è un framework di gradient boosting che utilizza algoritmi di apprendimento basati su alberi. È progettato per essere distribuito ed efficiente con i seguenti vantaggi:

• Velocità di addestramento più veloce e maggiore efficienza
• Minore utilizzo della memoria
• Migliore accuratezza
• Apprendimento parallelo e su GPU supportato
• Capace di gestire dati su larga scala

Il framework è un gradient boosting veloce e ad alte prestazioni basato su algoritmi ad albero decisionale, usato per la classificazione, la classificazione e molti altri compiti di apprendimento automatico. È stato sviluppato nell’ambito del Distributed Machine Learning Toolkit Project di Microsoft.

Siccome il LightGBM è basato su algoritmi ad albero decisionale, divide l’albero in base alla foglia con il miglior adattamento mentre altri algoritmi di boosting dividono l’albero in base alla profondità o al livello piuttosto che in base alla foglia. Così, quando si cresce sulla stessa foglia in Light GBM, l’algoritmo leaf-wise può ridurre più perdite dell’algoritmo level-wise e quindi risulta in una precisione molto migliore che raramente può essere raggiunta da uno qualsiasi degli algoritmi di boosting esistenti.

Inoltre, è sorprendentemente molto veloce, da cui la parola ‘Light’.

Riferimento all’articolo per saperne di più su LightGBM: https://www.analyticsvidhya.com/blog/2017/06/which-algorithm-takes-the-crown-light-gbm-vs-xgboost/

Codice Python:

data = np.random.rand(500, 10) # 500 entities, each contains 10 featureslabel = np.random.randint(2, size=500) # binary targettrain_data = lgb.Dataset(data, label=label)test_data = train_data.create_valid('test.svm')param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}param = 'auc'num_round = 10bst = lgb.train(param, train_data, num_round, valid_sets=)bst.save_model('model.txt')# 7 entities, each contains 10 featuresdata = np.random.rand(7, 10)ypred = bst.predict(data)

R Code:

library(RLightGBM)data(example.binary)#Parametersnum_iterations <- 100config <- list(objective = "binary", metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)#Create data handle and boosterhandle.data <- lgbm.data.create(x)lgbm.data.setField(handle.data, "label", y)handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))#Train for num_iterations iterations and eval every 5 stepslgbm.booster.train(handle.booster, num_iterations, 5)#Predictpred <- lgbm.booster.predict(handle.booster, x.test)#Test accuracysum(y.test == (y.pred > 0.5)) / length(y.test)#Save model (can be loaded again via lgbm.booster.load(filename))lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")

Se avete familiarità con il pacchetto Caret in R, questo è un altro modo di implementare il LightGBM.

require(caret)require(RLightGBM)data(iris)model <-caretModel.LGBM()fit <- train(Species ~ ., data = iris, method=model, verbosity = 0)print(fit)y.pred <- predict(fit, iris)library(Matrix)model.sparse <- caretModel.LGBM.sparse()#Generate a sparse matrixmat <- Matrix(as.matrix(iris), sparse = T)fit <- train(data.frame(idx = 1:nrow(iris)), iris$Species, method = model.sparse, matrix = mat, verbosity = 0)print(fit)

10.4. Catboost

CatBoost è un algoritmo di apprendimento automatico recentemente reso open-source da Yandex. Può facilmente integrarsi con framework di deep learning come TensorFlow di Google e Core ML di Apple.

La parte migliore di CatBoost è che non richiede un ampio addestramento dei dati come altri modelli ML, e può lavorare su una varietà di formati di dati; non compromettendo quanto possa essere robusto.

Assicuratevi di gestire bene i dati mancanti prima di procedere con l’implementazione.

Catboost può trattare automaticamente le variabili categoriche senza mostrare l’errore di conversione del tipo, il che vi aiuta a concentrarvi sul sintonizzare meglio il vostro modello piuttosto che risolvere errori banali.

Per saperne di più su Catboost consultate questo articolo: https://www.analyticsvidhya.com/blog/2017/08/catboost-automated-categorical-data/

Codice Python:

import pandas as pdimport numpy as npfrom catboost import CatBoostRegressor#Read training and testing filestrain = pd.read_csv("train.csv")test = pd.read_csv("test.csv")#Imputing missing values for both train and testtrain.fillna(-999, inplace=True)test.fillna(-999,inplace=True)#Creating a training set for modeling and validation set to check model performanceX = train.drop(, axis=1)y = train.Item_Outlet_Salesfrom sklearn.model_selection import train_test_splitX_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)categorical_features_indices = np.where(X.dtypes != np.float)#importing library and building modelfrom catboost import CatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)submission = pd.DataFrame()submission = testsubmission = testsubmission = model.predict(test)

Codice R:

set.seed(1)require(titanic)require(caret)require(catboost)tt <- titanic::titanic_traindata <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")x <- datay <- datafit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3, rsm = 0.95, border_count = 64)report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)print(report)importance <- varImp(report, scale = FALSE)print(importance)

Progetti

Ora, è il momento di fare il grande passo e giocare con altri set di dati reali. Sei pronto a raccogliere la sfida? Accelera il tuo viaggio nella scienza dei dati con i seguenti problemi pratici:

	Problema pratico: Sfida Previsione della domanda di cibo	Prevedere la domanda di pasti per una società di consegna pasti
	Problema pratico: HR Analytics Challenge	Identificare i dipendenti che hanno più probabilità di essere promossi
	Problema pratico: Prevedere il numero di voti in alto	Prevedere il numero di voti in alto su una domanda posta ad una domanda online & piattaforma di risposta

Note finali

Allora, sono sicuro che avrete un’idea degli algoritmi di apprendimento automatico comunemente usati. La mia unica intenzione dietro la scrittura di questo articolo e la fornitura dei codici in R e Python è quella di farvi iniziare subito. Se siete desiderosi di padroneggiare l’apprendimento automatico, iniziate subito. Affrontate i problemi, sviluppate una comprensione fisica del processo, applicate questi codici e vedrete il divertimento!