Tilfældig skovklassificeringsvejledning: Sådan bruges træbaserede algoritmer til maskinindlæring

Træbaserede algoritmer er populære maskinlæringsmetoder, der bruges til at løse overvågede læringsproblemer. Disse algoritmer er fleksible og kan løse enhver form for problem ved hånden (klassificering eller regression).

Træbaserede algoritmer har en tendens til at bruge middelværdien for kontinuerlige funktioner eller tilstand for kategoriske funktioner, når man forudsiger træningseksempler i de regioner, de tilhører. De producerer også forudsigelser med høj nøjagtighed , stabilitet og let fortolkning .

Eksempler på træbaserede algoritmer

Der er forskellige træbaserede algoritmer, som du kan bruge, f.eks

  • Beslutningstræer
  • Tilfældig skov
  • Gradient Boosting
  • Bagging (Bootstrap Aggregation)

Så enhver dataforsker bør lære disse algoritmer og bruge dem i deres maskinindlæringsprojekter.

I denne artikel lærer du mere om tilfældig skovalgoritme. Efter at have gennemført denne artikel, skal du være dygtig til at bruge den tilfældige skovalgoritme til at løse og opbygge forudsigelige modeller til klassificeringsproblemer med scikit-learning.

Hvad er tilfældig skov?

Tilfældig skov er en af ​​de mest populære træbaserede overvågede læringsalgoritmer. Det er også den mest fleksible og nemme at bruge.

Algoritmen kan bruges til at løse både klassificerings- og regressionsproblemer. Tilfældig skov har tendens til at kombinere hundreder afbeslutningstræerog træner derefter hvert beslutningstræ på en anden prøve af observationerne.

De endelige forudsigelser af den tilfældige skov foretages ved at beregne gennemsnittet af forudsigelserne for hvert enkelt træ.

Fordelene ved tilfældige skove er mange. De individuelle beslutningstræer har tendens til at overdrive træningsdataene, men tilfældig skov kan afbøde problemet ved at beregne forudsigelsesresultaterne fra forskellige træer. Dette giver tilfældige skove en højere forudsigelsesnøjagtighed end et enkelt beslutningstræ.

Den tilfældige skovalgoritme kan også hjælpe dig med at finde funktioner, der er vigtige i dit datasæt. Det ligger i bunden af ​​Boruta-algoritmen, som vælger vigtige funktioner i et datasæt.

Tilfældig skov er blevet brugt i en række applikationer, for eksempel til at give anbefalinger om forskellige produkter til kunder inden for e-handel.

I medicin kan en tilfældig skovalgoritme bruges til at identificere patientens sygdom ved at analysere patientens medicinske journal.

Også i banksektoren kan det bruges til let at afgøre, om kunden er svigagtig eller legitim.

Hvordan fungerer Random Forest-algoritmen?

Den tilfældige skovalgoritme fungerer ved at udføre følgende trin:

Trin 1 : Algoritmen vælger tilfældige prøver fra det medfølgende datasæt.

Trin 2: Algoritmen opretter et beslutningstræ for hver valgt prøve. Derefter får det et forudsigelsesresultat fra hvert oprettede beslutningstræ.

Trin 3: Overvågning udføres derefter for hvert forudsagt resultat. For et klassificeringsproblem bruger det tilstand , og for et regressionsproblem bruger det middel .

Trin 4 : Og endelig vælger algoritmen det mest valgte stemningsresultat som den endelige forudsigelse.

Tilfældig skov i praksis

Nu hvor du kender ind og ud af den tilfældige skovalgoritme, lad os bygge en tilfældig skovklassifikator.

Vi bygger en tilfældig skovklassifikator ved hjælp af Pima Indians Diabetes-datasættet. Pima Indians Diabetes Dataset indebærer forudsigelse af starten på diabetes inden for 5 år baseret på de medfølgende medicinske detaljer. Dette er et binært klassificeringsproblem.

Vores opgave er at analysere og oprette en model på datasættet Pima Indian Diabetes for at forudsige, om en bestemt patient har en risiko for at udvikle diabetes givet andre uafhængige faktorer.

Vi starter med at importere vigtige pakker, som vi vil bruge til at indlæse datasættet og oprette en tilfældig skovklassifikator. Vi bruger scikit-learning-biblioteket til at indlæse og bruge den tilfældige skovalgoritme.

# import important packages import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler, MinMaxScaler import pandas_profiling from matplotlib import rcParams import warnings warnings.filterwarnings("ignore") # figure size in inches rcParams["figure.figsize"] = 10, 6 np.random.seed(42)

Datasæt

Indlæs derefter datasættet fra datakataloget:

# Load dataset data = pd.read_csv("../data/pima_indians_diabetes.csv")

Nu kan vi observere prøven af ​​datasættet.

 # show sample of the dataset data.sample(5)

Som du kan se, har vi i vores datasæt forskellige funktioner med numeriske værdier.

Lad os forstå listen over funktioner, vi har i dette datasæt.

# show columns data.columns

I dette datasæt er der 8 inputfunktioner og 1 output / target-funktion. Manglende værdier menes at være kodet med nul værdier. Betydningen af ​​variabelnavne er som følger (fra første til sidste funktion):

  • Antal gange gravid.
  • Plasmaglukosekoncentration 2 timer i en oral glukostolerancetest.
  • Diastolisk blodtryk (mm Hg).
  • Triceps hudfoldtykkelse (mm).
  • 2-timers seruminsulin (mu U / ml).
  • Kropsmasseindeks (vægt i kg / (højde i m) ^ 2).
  • Diabetes stamtavle funktion.
  • Alder (år).
  • Klassevariabel (0 eller 1).

Derefter opdeler vi datasættet i uafhængige funktioner og målfunktion. Vores målfunktion for dette datasæt kaldes klasse.

# split data into input and taget variable(s) X = data.drop("class", axis=1) y = data["class"]

Forbehandling af datasættet

Before we create a model we need to standardize our independent features by using the standardScaler method from scikit-learn.

# standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X)

You can learn more on how and why to standardize your data from this article by clicking here.

Splitting the dataset into Training and Test data

We now split our processed dataset into training and test data. The test data will be 10% of the entire processed dataset.

# split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

Building the Random Forest Classifier

Now is time to create our random forest classifier and then train it on the train set. We will also pass the number of trees (100) in the forest we want to use through theparameter called n_estimators.

# create the classifier classifier = RandomForestClassifier(n_estimators=100) # Train the model using the training sets classifier.fit(X_train, y_train)

The above output shows different parameter values of the random forest classifier used during the training process on the train data.

After training we can perform prediction on the test data.

# predictin on the test set y_pred = classifier.predict(X_test)

Then we check the accuracy using actual and predicted values from the test data.

# Calculate Model Accuracy print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8051948051948052

Our accuracy is around 80.5% which is good. But we can always make it better.

Identify Important Features

As I said before, we can also check the important features by using the feature_importances_ variable from the random forest algorithm in scikit-learn.

# check Important features feature_importances_df = pd.DataFrame( {"feature": list(X.columns), "importance": classifier.feature_importances_} ).sort_values("importance", ascending=False) # Display feature_importances_df

The figure above shows the relative importance of features and their contribution to the model. We can also visualize these features and their  scores using the seaborn and matplotlib libraries.

# visualize important featuers # Creating a bar plot sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance) # Add labels to your plt.xlabel("Feature Importance Score") plt.ylabel("Features") plt.title("Visualizing Important Features") plt.xticks( rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large" ) plt.show()

From the figure above, you can see the triceps_skinfold_thickness feature has low importance and does not contribute much to the prediction.

This means that we can remove this feature and train our random forest classifier again and then see if it can improve its performance on the test data.

# load data with selected features X = data.drop(["class", "triceps_skinfold_thickness"], axis=1) y = data["class"] # standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

We will train the random forest algorithm with the selected processed features from our dataset, perform predictions, and then find the accuracy of the model.

# Create a Random Classifier clf = RandomForestClassifier(n_estimators=100) # Train the model using the training sets clf.fit(X_train, y_train) # prediction on test set y_pred = clf.predict(X_test) # Calculate Model Accuracy, print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8181818181818182

Now the model accuracy has increased from 80.5% to 81.8% after we removed the least important feature called triceps_skinfold_thickness.

This suggests that it is very important to check important features and see if you can remove the least important features to increase your model's performance.

Wrapping up

Træbaserede algoritmer er virkelig vigtige for enhver dataforsker at lære. I denne artikel har du lært det grundlæggende i træbaserede algoritmer, og hvordan man opretter en klassificeringsmodel ved hjælp af den tilfældige skovalgoritme.

Jeg anbefaler også, at du prøver andre typer træbaserede algoritmer, såsom algoritmen Ekstra træer.

Du kan downloade datasættet og den bærbare computer, der bruges i denne artikel her: //github.com/Davisy/Random-Forest-classification-Tutorial

Tillykke, du har nået slutningen af ​​denne artikel!

Hvis du har lært noget nyt eller haft glæde af at læse denne artikel, skal du dele det, så andre kan se det. Indtil da, vi ses i det næste indlæg! Jeg kan også nås på Twitter @Davis_McDavid