Juhusliku metsaklassifikaatori õpetus: kuidas puupõhiseid algoritme masinõppeks kasutada

Puupõhised algoritmid on populaarsed masinõppemeetodid, mida kasutatakse juhendatud õppeprobleemide lahendamiseks. Need algoritmid on paindlikud ja suudavad lahendada mis tahes tüüpi probleeme (klassifikatsioon või regressioon).

Puupõhised algoritmid kasutavad pidevate funktsioonide keskmist või kategooriliste tunnuste režiimi , kui nad teevad prognoose koolitusvalimite kohta piirkondades, kuhu nad kuuluvad. Samuti annavad need suure täpsuse , stabiilsuse ja hõlpsasti tõlgendatavad ennustused .

Puupõhiste algoritmide näited

Võite kasutada erinevaid puupõhiseid algoritme, näiteks

  • Otsustuspuud
  • Juhuslik mets
  • Gradient Boosting
  • Kottide pakkimine (Bootstrapi liitmine)

Seega peaks iga andmeteadlane neid algoritme õppima ja masinõppe projektides kasutama.

Selles artiklis leiate lisateavet juhusliku metsa algoritmi kohta. Pärast selle artikli valmimist peaksite oskama juhusliku metsaalgoritmi kasutamist, et lahendada ja koostada ennustavaid mudeleid scikit-learni klassifitseerimise probleemide jaoks.

Mis on juhuslik mets?

Juhuslik mets on üks populaarsemaid puupõhiseid juhendatud õppealgoritme. See on ka kõige paindlikum ja hõlpsam kasutada.

Algoritmi saab kasutada nii klassifitseerimis- kui ka regressiooniprobleemide lahendamiseks. Juhuslik mets kipub ühendama saduotsustuspuudja treenib seejärel iga otsustuspuu vaatluste erineva valimi põhjal.

Juhusliku metsa lõplikud ennustused tehakse iga üksiku puu ennustuste keskmistamise teel.

Juhuslike metsade eelised on arvukad. Üksikud otsustuspuud kipuvad treeningandmetega üle sobima , kuid juhuslik mets võib seda probleemi leevendada, keskmistades erinevate puude ennustustulemused. See annab juhuslikele metsadele suurema prognoositava täpsuse kui üks otsustuspuu.

Juhuslik metsaalgoritm aitab teil leida ka andmekogumis olulisi funktsioone . See asub Boruta algoritmi baasil, mis valib andmekogumis olulised tunnused.

Juhuslikku metsa on kasutatud erinevates rakendustes, näiteks e-kaubanduses klientidele erinevate toodete soovituste andmiseks.

Meditsiinis saab patsiendi haiguse tuvastamiseks kasutada juhuslikku metsaalgoritmi, analüüsides patsiendi haiguslugu.

Ka pangandussektoris saab selle abil hõlpsalt kindlaks teha, kas klient on petlik või seaduslik.

Kuidas töötab juhusliku metsa algoritm?

Juhuslik metsaalgoritm töötab järgmiste toimingute abil:

1. samm : algoritm valib juhuslikud proovid pakutavast andmekogumist.

2. samm: algoritm loob iga valitud valimi jaoks otsustuspuu. Siis saab see igast loodud otsustuspuust ennustustulemuse.

3. samm: Seejärel tehakse iga prognoositud tulemuse jaoks vastavus. Klassifikatsiooniprobleemi jaoks kasutab see režiimi ja regressiooniprobleemi jaoks keskmist .

4. samm : lõpuks valib algoritm lõplikuks ennustuseks enim hääletatud ennustustulemuse.

Juhuslik mets praktikas

Nüüd, kui teate juhusliku metsaalgoritmi häid külgi, ehitame juhusliku metsa klassifikaatori.

Ehitame juhusliku metsaklassifikaatori, kasutades Pima Indians Diabetes andmekogumit. Pima indiaanlaste diabeediandmekogum hõlmab diabeedi tekkimise prognoosimist 5 aasta jooksul esitatud meditsiiniliste üksikasjade põhjal. See on binaarse klassifikatsiooni probleem.

Meie ülesanne on analüüsida ja luua mudel Pima Indian Diabetes andmekogumis, et ennustada, kas konkreetsel patsiendil on teiste sõltumatute tegurite korral diabeet.

Alustame oluliste pakettide importimisega, mida kasutame andmekogumi laadimiseks ja juhusliku metsaklassifikaatori loomiseks. Juhusliku metsaalgoritmi laadimiseks ja kasutamiseks kasutame teemat scikit-learn.

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

Andmekogum

Seejärel laadige andmekataloog andmestik:

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

Nüüd saame jälgida andmekogumi näidist.

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

As you can see, in our dataset we have different features with numerical values.

Let's understand the list of features we have in this dataset.

# show columns data.columns

In this dataset, there are 8 input features and 1 output / target feature. Missing values are believed to be encoded with zero values. The meaning of the variable names are as follows (from the first to the last feature):

  • Number of times pregnant.
  • Plasma glucose concentration a 2 hours in an oral glucose tolerance test.
  • Diastolic blood pressure (mm Hg).
  • Triceps skinfold thickness (mm).
  • 2-hour serum insulin (mu U/ml).
  • Body mass index (weight in kg/(height in m)^2).
  • Diabetes pedigree function.
  • Age (years).
  • Class variable (0 or 1).

Then we split the dataset into independent features and target feature. Our target feature for this dataset is called class.

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

Preprocessing the Dataset

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

Puupõhised algoritmid on iga andmeteadlase õppimiseks tõesti olulised. Selles artiklis olete õppinud puupõhiste algoritmide põhitõdesid ja juhusliku metsaalgoritmi abil klassifikatsioonimudeli loomist.

Samuti soovitan teil proovida muud tüüpi puupõhiseid algoritme, näiteks Extra-trees algoritmi.

Selles artiklis kasutatud andmekogumi ja märkmiku saate alla laadida siit: //github.com/Davisy/Random-Forest-classification-Tutorial

Palju õnne, olete jõudnud selle artikli lõpuni!

Kui õppisite midagi uut või meeldis seda artiklit lugeda, jagage seda, et teised seda näeksid. Seni näeme järgmises postituses! Minuga saab ühendust ka Twitteris @Davis_McDavid