Vodič za slučajni klasifikator šuma: Kako koristiti algoritme temeljene na drvetu za strojno učenje

Algoritmi temeljeni na stablima popularne su metode strojnog učenja koje se koriste za rješavanje nadziranih problema učenja. Ti su algoritmi fleksibilni i mogu riješiti bilo koju vrstu problema (klasifikacija ili regresija).

Drvo-based algoritmi imaju tendenciju da koriste srednja za kontinuirano značajke ili načinu rada za kategoričke mogućnosti prilikom predviđanja na trening uzoraka u regijama kojoj pripadaju. Oni također proizvode predviđanja s velikom točnošću , stabilnošću i lakoćom interpretacije .

Primjeri algoritama temeljenih na stablima

Postoje različiti algoritmi temeljeni na stablima koje možete koristiti, kao što su

  • Stabla odlučivanja
  • Slučajna šuma
  • Pojačavanje gradijenta
  • Vreće (agregacija Bootstrapa)

Dakle, svaki bi znanstvenik podataka trebao naučiti te algoritme i koristiti ih u svojim projektima strojnog učenja.

U ovom ćete članku saznati više o algoritmu slučajnih šuma. Nakon završetka ovog članka trebali biste biti vješti u korištenju algoritma slučajnih šuma za rješavanje i izgradnju prediktivnih modela za klasifikacijske probleme s scikit-learnom.

Što je slučajna šuma?

Slučajna šuma jedan je od najpopularnijih algoritama učenja pod nadzorom na drvetu. Također je najfleksibilniji i najjednostavniji za upotrebu.

Algoritam se može koristiti za rješavanje problema klasifikacije i regresije. Slučajna šuma obično kombinira stotinestabla odlučivanjaa zatim trenira svako stablo odluke na različitom uzorku promatranja.

Konačna predviđanja slučajne šume daju se prosjekom predviđanja svakog pojedinačnog stabla.

Prednosti slučajnih šuma su brojne. Pojedinačna stabla odlučivanja imaju tendenciju da se prekomjerno prilagode podacima o treningu, ali slučajna šuma može ublažiti taj problem usrednjavanjem rezultata predviđanja s različitih stabala. To daje slučajnim šumama veću predvidivu točnost od jednog stabla odlučivanja.

Algoritam slučajnih šuma također vam može pomoći da pronađete značajke koje su važne u vašem skupu podataka. Leži u osnovi algoritma Boruta, koji odabire važne značajke u skupu podataka.

Slučajna šuma korištena je u raznim aplikacijama, na primjer za pružanje preporuka različitih proizvoda kupcima u e-trgovini.

U medicini se slučajni šumski algoritam može koristiti za identificiranje bolesti pacijenta analizom pacijentovog zdravstvenog kartona.

Također se u bankarskom sektoru može koristiti za lako utvrđivanje je li klijent prijevara ili legitiman.

Kako funkcionira algoritam Random Forest?

Algoritam slučajnih šuma radi ispunjavanjem sljedećih koraka:

Korak 1 : Algoritam odabire slučajne uzorke iz ponuđenog skupa podataka.

Korak 2: Algoritam će stvoriti stablo odluke za svaki odabrani uzorak. Tada će dobiti rezultat predviđanja iz svakog stvorenog stabla odluka.

Korak 3: Zatim će se izvršiti glasanje za svaki predviđeni rezultat. Za problem klasifikacije koristit će način , a za problem regresije značenje .

Korak 4 : I na kraju, algoritam će odabrati konačni rezultat predviđanja s najviše glasova.

Slučajna šuma u praksi

Sad kad znate detalje i algoritme slučajnih šuma, napravimo klasifikator slučajnih šuma.

Izgradit ćemo slučajni klasifikator šuma pomoću skupa podataka Pima Indians Diabetes. Skup podataka o dijabetesu Pima Indians uključuje predviđanje pojave dijabetesa u roku od 5 godina na temelju danih medicinskih detalja. Ovo je binarni problem klasifikacije.

Naš je zadatak analizirati i stvoriti model na skupu podataka o indijskom dijabetesu Pima kako bismo predvidjeli postoji li određeni pacijent u riziku od razvoja dijabetesa s obzirom na druge neovisne čimbenike.

Počet ćemo s uvozom važnih paketa koje ćemo koristiti za učitavanje skupa podataka i stvaranje slučajnog klasifikatora šuma. Upotrijebit ćemo scikit-learn knjižnicu za učitavanje i upotrebu slučajnog algoritma šuma.

# 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)

Skup podataka

Zatim učitajte skup podataka iz direktorija podataka:

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

Sada možemo promatrati uzorak skupa podataka.

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

Kao što vidite, u našem skupu podataka imamo različite značajke s numeričkim vrijednostima.

Razumijemo popis značajki koje imamo u ovom skupu podataka.

# show columns data.columns

U ovom skupu podataka nalazi se 8 ulaznih značajki i 1 izlazno / ciljna značajka. Vjeruje se da su vrijednosti koje nedostaju kodirane s nula vrijednosti. Značenje imena varijabli je sljedeće (od prve do posljednje značajke):

  • Broj trudnoća.
  • Koncentracija glukoze u plazmi 2 sata u oralnom testu tolerancije na glukozu.
  • Dijastolički krvni tlak (mm Hg).
  • Debljina nabora tricepsa (mm).
  • 2-satni serumski inzulin (mu U / ml).
  • Indeks tjelesne mase (težina u kg / (visina u m) ^ 2).
  • Funkcija rodovnika dijabetesa.
  • Dob (godine).
  • Varijabla razreda (0 ili 1).

Zatim skup podataka dijelimo na neovisne i ciljane značajke. Naša ciljana značajka za ovaj skup podataka naziva se klasa.

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

Predobrada skupa podataka

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

Tree-based algorithms are really important for every data scientist to learn. In this article, you've learned the basics of tree-based algorithms and how to create a classification model by using the random forest algorithm.

I also recommend you try other types of tree-based algorithms such as the Extra-trees algorithm.

You can download the dataset and notebook used in this article here: //github.com/Davisy/Random-Forest-classification-Tutorial

Congratulations, you have made it to the end of this article!

If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! I can also be reached on Twitter @Davis_McDavid