Random Forest è un popolare algoritmo di machine learning che appartiene alla tecnica di apprendimento supervisionato. Può essere utilizzato sia per problemi di classificazione che di regressione in ML. Si basa sul concetto di apprendimento d'insieme, che è un processo di combinare più classificatori per risolvere un problema complesso e migliorare le prestazioni del modello.
Come suggerisce il nome, 'Random Forest è un classificatore che contiene una serie di alberi decisionali su vari sottoinsiemi del dato set di dati e prende la media per migliorare l'accuratezza predittiva di quel set di dati.' Invece di fare affidamento su un albero decisionale, la foresta casuale prende la previsione da ciascun albero e, in base alla maggioranza dei voti delle previsioni, prevede il risultato finale.
Il maggior numero di alberi nella foresta porta ad una maggiore precisione e previene il problema del sovradattamento.
1 milione in cifre
Il diagramma seguente spiega il funzionamento dell'algoritmo Random Forest:
Nota: per comprendere meglio l'algoritmo della foresta casuale, è necessario conoscere l'algoritmo dell'albero delle decisioni.
Presupposti per la foresta casuale
Poiché la foresta casuale combina più alberi per prevedere la classe del set di dati, è possibile che alcuni alberi decisionali possano prevedere l'output corretto, mentre altri no. Ma insieme, tutti gli alberi prevedono il risultato corretto. Pertanto, di seguito sono riportate due ipotesi per un migliore classificatore di foreste casuali:
- Dovrebbero esserci alcuni valori effettivi nella variabile caratteristica del set di dati in modo che il classificatore possa prevedere risultati accurati anziché un risultato indovinato.
- Le previsioni di ciascun albero devono avere correlazioni molto basse.
Perché usare la foresta casuale?
Di seguito sono riportati alcuni punti che spiegano perché dovremmo utilizzare l'algoritmo Random Forest:
- Richiede meno tempo di addestramento rispetto ad altri algoritmi.
- Prevede l'output con elevata precisione, anche per set di dati di grandi dimensioni e viene eseguito in modo efficiente.
- Può anche mantenere la precisione quando manca una grande percentuale di dati.
Come funziona l'algoritmo Random Forest?
La foresta casuale funziona in due fasi: la prima consiste nel creare la foresta casuale combinando N alberi decisionali e la seconda nel fare previsioni per ciascun albero creato nella prima fase.
Il processo di lavoro può essere spiegato nei passaggi e nel diagramma seguenti:
Passo 1: Seleziona punti dati K casuali dal set di addestramento.
Passo 2: Costruisci gli alberi decisionali associati ai punti dati selezionati (sottoinsiemi).
Passaggio 3: Scegli il numero N per gli alberi decisionali che desideri costruire.
Passaggio 4: Ripeti i passaggi 1 e 2.
formattazione stringhe java
Passaggio 5: Per i nuovi punti dati, trova le previsioni di ciascun albero decisionale e assegna i nuovi punti dati alla categoria che ottiene la maggioranza dei voti.
Il funzionamento dell'algoritmo può essere meglio compreso dall'esempio seguente:
Esempio: Supponiamo che esista un set di dati che contiene più immagini di frutta. Pertanto, questo set di dati viene assegnato al classificatore della foresta casuale. Il dataset è suddiviso in sottoinsiemi e assegnato a ciascun albero decisionale. Durante la fase di training, ogni albero decisionale produce un risultato di previsione e, quando si verifica un nuovo punto dati, sulla base della maggior parte dei risultati, il classificatore Random Forest prevede la decisione finale. Considera l'immagine qui sotto:
Applicazioni della foresta casuale
Sono principalmente quattro i settori in cui è maggiormente utilizzata la Random Forest:
Vantaggi della foresta casuale
- Random Forest è in grado di eseguire sia attività di classificazione che di regressione.
- È in grado di gestire set di dati di grandi dimensioni con elevata dimensionalità.
- Migliora la precisione del modello e previene il problema del sovradattamento.
Svantaggi della foresta casuale
- Sebbene la foresta casuale possa essere utilizzata sia per le attività di classificazione che per quelle di regressione, non è più adatta per le attività di regressione.
Implementazione Python dell'algoritmo della foresta casuale
Ora implementeremo l'albero dell'algoritmo della foresta casuale utilizzando Python. Per questo utilizzeremo lo stesso set di dati 'user_data.csv' che abbiamo utilizzato nei precedenti modelli di classificazione. Utilizzando lo stesso set di dati, possiamo confrontare il classificatore Random Forest con altri modelli di classificazione come Classificatore dell'albero decisionale, KNN, SVM, regressione logistica, ecc.
mappa java iteratore
Le fasi di implementazione sono riportate di seguito:
- Fase di pre-elaborazione dei dati
- Adattamento dell'algoritmo della foresta casuale al set di allenamento
- Predire il risultato del test
- Verifica l'accuratezza del risultato (creazione della matrice di confusione)
- Visualizzazione del risultato del set di test.
1.Passo di pre-elaborazione dei dati:
Di seguito è riportato il codice per la fase di pre-elaborazione:
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Nel codice sopra, abbiamo pre-elaborato i dati. Dove abbiamo caricato il set di dati, che è dato come:
2. Adattamento dell'algoritmo Random Forest al training set:
Ora adatteremo l'algoritmo della foresta casuale al set di addestramento. Per adattarlo, importeremo il file RandomForestClassificatore classe da sklearn.ensemble biblioteca. Il codice è riportato di seguito:
#Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train)
Nel codice sopra, l'oggetto classificatore accetta i seguenti parametri:
Produzione:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)
3. Previsione del risultato del test set
Poiché il nostro modello è adattato al set di addestramento, ora possiamo prevedere il risultato del test. Per la previsione, creeremo un nuovo vettore di previsione y_pred. Di seguito è riportato il codice:
#Predicting the test set result y_pred= classifier.predict(x_test)
Produzione:
Il vettore di previsione è dato come:
Controllando il vettore di previsione di cui sopra e il vettore reale del test set, possiamo determinare le previsioni errate effettuate dal classificatore.
fine Java
4. Creazione della matrice di confusione
Ora creeremo la matrice di confusione per determinare le previsioni corrette e quelle errate. Di seguito è riportato il codice:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produzione:
Come possiamo vedere nella matrice sopra, ci sono 4+4= 8 pronostici errati E 64+28= 92 pronostici corretti.
5. Visualizzazione del risultato del set di allenamento
Qui visualizzeremo il risultato del set di allenamento. Per visualizzare il risultato del training set tracciamo un grafico per il classificatore della foresta casuale. Il classificatore prevederà sì o no per gli utenti che hanno acquistato o non acquistato l'auto SUV come abbiamo fatto nella regressione logistica. Di seguito è riportato il codice:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Produzione:
L'immagine sopra è il risultato della visualizzazione per il classificatore Random Forest che lavora con il risultato del set di training. È molto simile al classificatore dell'albero decisionale. Ogni punto dati corrisponde a ciascun utente di user_data e le regioni viola e verde sono le regioni di previsione. La regione viola è classificata per gli utenti che non hanno acquistato l'auto SUV, mentre la regione verde è per gli utenti che hanno acquistato il SUV.
c++ int in stringa
Quindi, nel classificatore Random Forest, abbiamo preso 10 alberi che hanno previsto Sì o NO per la variabile Acquistato. Il classificatore ha preso la maggior parte delle previsioni e ha fornito il risultato.
6. Visualizzazione del risultato del set di test
Ora visualizzeremo il risultato del set di test. Di seguito è riportato il codice:
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Produzione:
L'immagine sopra è il risultato della visualizzazione per il set di test. Possiamo verificare che ci sia un numero minimo di previsioni errate (8) senza il problema dell'Overfitting. Otterremo risultati diversi modificando il numero di alberi nel classificatore.