Random Forest Regressie is een veelzijdige machine-learningtechniek voor het voorspellen van numerieke waarden. Het combineert de voorspellingen van meerdere beslissingsbomen om overfitting te verminderen en de nauwkeurigheid te verbeteren. Python's machinaal leren bibliotheken maken het eenvoudig om deze aanpak te implementeren en te optimaliseren.
Ensemble leren
Ensemble learning is een machine learning-techniek die de voorspellingen van meerdere modellen combineert om een nauwkeurigere en stabielere voorspelling te creëren. Het is een aanpak die gebruik maakt van de collectieve intelligentie van meerdere modellen om de algehele prestaties van het leersysteem te verbeteren.
Soorten ensemblemethoden
Er zijn verschillende soorten ensembleleermethoden, waaronder:
- Opzakken (Bootstrap-aggregatie): Deze methode omvat het trainen van meerdere modellen op willekeurige subsets van de trainingsgegevens. De voorspellingen van de individuele modellen worden vervolgens gecombineerd, meestal door middel van middelen.
- Stimuleren: Deze methode omvat het trainen van een reeks modellen, waarbij elk volgend model zich richt op de fouten die door het vorige model zijn gemaakt. De voorspellingen worden gecombineerd met behulp van een gewogen stemschema.
- Stapelen: Bij deze methode worden de voorspellingen van de ene set modellen gebruikt als invoerkenmerken voor een ander model. De uiteindelijke voorspelling wordt gedaan door het tweede-niveaumodel.
Willekeurig bos
Een willekeurig bos is een ensemble-leermethode die de voorspellingen van meerdere beslissingsbomen combineert om een nauwkeurigere en stabielere voorspelling te produceren. Het is een soort begeleid leeralgoritme dat kan worden gebruikt voor zowel classificatie- als regressietaken.
Elk beslissingsboom heeft een hoge variantie, maar als we ze allemaal parallel combineren, is de resulterende variantie laag omdat elke beslissingsboom perfect wordt getraind op die specifieke voorbeeldgegevens, en daarom is de uitvoer niet afhankelijk van één beslissingsboom maar van meerdere beslissingsbomen. In het geval van een classificatieprobleem wordt de uiteindelijke output verkregen met behulp van de classificatie voor meerderheidsstemmen. In het geval van een regressieprobleem is de uiteindelijke output het gemiddelde van alle outputs. Dit onderdeel heet Aggregatie .
Willekeurig bosregressiemodel werkt
Wat is willekeurige bosregressie?
Willekeurige bosregressie in machinaal leren is een technische set in staat om beide uit te voeren regressie en classificatie taken met het gebruik van meerdere beslissingsbomen en een techniek genaamd Bootstrap en Aggregatie, algemeen bekend als inpakken . Het basisidee hierachter is om meerdere beslissingsbomen te combineren bij het bepalen van de uiteindelijke output, in plaats van te vertrouwen op individuele beslissingsbomen.
Random Forest heeft meerdere beslissingsbomen als basisleermodellen. We voeren willekeurig rijsteekproeven uit en beschikken over steekproeven uit de dataset, waardoor voorbeelddatasets voor elk model worden gevormd. Dit onderdeel heet Bootstrap.
We moeten de Random Forest-regressietechniek benaderen zoals elke andere machinaal leren techniek.
- Ontwerp een specifieke vraag of gegevens en zorg ervoor dat de bron de benodigde gegevens bepaalt.
- Zorg ervoor dat de gegevens in een toegankelijk formaat zijn, anders converteer ze naar het vereiste formaat.
- Specificeer alle merkbare afwijkingen en ontbrekende gegevenspunten die nodig kunnen zijn om de vereiste gegevens te verkrijgen.
- Maak een machine learning-model.
- Stel het basismodel in dat u wilt bereiken
- Train het data machine learning-model.
- Met testgegevens inzicht geven in het model
- Vergelijk nu de prestatiestatistieken van zowel de testgegevens als de voorspelde gegevens van het model.
- Als het niet aan uw verwachtingen voldoet, kunt u proberen uw model dienovereenkomstig te verbeteren, uw gegevens te dateren, of een andere techniek voor gegevensmodellering te gebruiken.
- In deze fase interpreteer je de verzamelde gegevens en rapporteer je dienovereenkomstig.
Willekeurige bosregressie in Python
In het onderstaande voorbeeld zullen we een soortgelijke voorbeeldtechniek gebruiken. Hieronder vindt u een stapsgewijze voorbeeldimplementatie van Random Forest Regression, op de dataset die hier kan worden gedownload: https://bit.ly/417n3N5
Python bibliotheken maken het ons heel gemakkelijk om de gegevens te verwerken en typische en complexe taken uit te voeren met één enkele regel code.
- Panda's – Deze bibliotheek helpt bij het laden van het dataframe in een 2D-arrayformaat en heeft meerdere functies om analysetaken in één keer uit te voeren.
- Numpy – Numpy-arrays zijn erg snel en kunnen in zeer korte tijd grote berekeningen uitvoeren.
- Matplotlib / Zeegeboren – Deze bibliotheek wordt gebruikt om visualisaties te tekenen.
- Sklearn – Deze module bevat meerdere bibliotheken met vooraf geïmplementeerde functies om taken uit te voeren, van de voorverwerking van gegevens tot de ontwikkeling en evaluatie van modellen.
- RandomForestRegressor – Dit is het regressiemodel dat is gebaseerd op het Random Forest-model of het ensemble-leren dat we in dit artikel zullen gebruiken met behulp van de sklearn-bibliotheek.
- leer: Deze bibliotheek is de kernmachine learning-bibliotheek in Python. Het biedt een breed scala aan tools voor het voorbewerken, modelleren, evalueren en implementeren van machine learning-modellen.
- LabelEncoder: Deze klasse wordt gebruikt om categorische gegevens in numerieke waarden te coderen.
- KNNImputer: Deze klasse wordt gebruikt om ontbrekende waarden in een gegevensset toe te schrijven met behulp van een k-dichtstbijzijnde burenbenadering.
- train_test_split: Deze functie wordt gebruikt om een dataset op te splitsen in trainings- en testsets.
- StandaardScaler: Deze klasse wordt gebruikt om kenmerken te standaardiseren door het gemiddelde te verwijderen en te schalen naar eenheidsvariantie.
- f1_score: Deze functie wordt gebruikt om de prestaties van een classificatiemodel te evalueren met behulp van de F1-score.
- RandomForestRegressor: Deze klasse wordt gebruikt om een willekeurig bosregressiemodel te trainen.
- cross_val_score: Deze functie wordt gebruikt om k-voudige kruisvalidatie uit te voeren om de prestaties van een model te evalueren
Stap 1: Bibliotheken importeren
Hier importeren we alle benodigde bibliotheken.
Python3
import> pandas as pd> import> matplotlib.pyplot as plt> import> seaborn as sns> import> sklearn> import> warnings> from> sklearn.preprocessing>import> LabelEncoder> from> sklearn.impute>import> KNNImputer> from> sklearn.model_selection>import> train_test_split> from> sklearn.preprocessing>import> StandardScaler> from> sklearn.metrics>import> f1_score> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.model_selection>import> cross_val_score> warnings.filterwarnings(>'ignore'>)> |
>
>
Stap 2: Gegevensset importeren
Laten we nu de dataset in het dataframe van de panda laden. Voor een betere gegevensverwerking en het benutten van de handige functies om complexe taken in één keer uit te voeren.
numpig logboek
Python3
df>=> pd.read_csv(>'Salaries.csv'>)> print>(df)> |
>
>
Uitgang:
Position Level Salary 0 Business Analyst 1 45000 1 Junior Consultant 2 50000 2 Senior Consultant 3 60000 3 Manager 4 80000 4 Country Manager 5 110000 5 Region Manager 6 150000 6 Partner 7 200000 7 Senior Partner 8 300000 8 C-level 9 500000 9 CEO 10 1000000>
Hier de.info()>methode biedt een snel overzicht van de structuur, gegevenstypen en geheugengebruik van de dataset.
Python3
df.info()> |
>
>
Uitgang:
RangeIndex: 10 entries, 0 to 9 Data columns (total 3 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Position 10 non-null object 1 Level 10 non-null int64 2 Salary 10 non-null int64 dtypes: int64(2), object(1) memory usage: 372.0+ bytes>
Stap 3: Data voorbereiding
Hier haalt de code twee subsets met gegevens uit de dataset en slaat deze op in afzonderlijke variabelen.
- Functies extraheren: Het extraheert de functies uit het DataFrame en slaat ze op in een variabele met de naam
X>. - Doelvariabele extraheren: Het extraheert de doelvariabele uit het DataFrame en slaat deze op in een variabele met de naam
y>.
Python3
# Assuming df is your DataFrame> X>=> df.iloc[:,>1>:>2>].values>#features> y>=> df.iloc[:,>2>].values># Target variable> |
>
dhanashree verma
>
Stap 4: Willekeurig bosregressormodel
De code verwerkt categorische gegevens door deze numeriek te coderen, combineert de verwerkte gegevens met numerieke gegevens en traint een Random Forest Regressie-model met behulp van de voorbereide gegevens.
Python3
git pull-syntaxis
import> pandas as pd> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.preprocessing>import> LabelEncoder> >Check>for> and> handle categorical variables> label_encoder>=> LabelEncoder()> x_categorical>=> df.select_dtypes(include>=>[>'object'>]).>apply>(label_encoder.fit_transform)> x_numerical>=> df.select_dtypes(exclude>=>[>'object'>]).values> x>=> pd.concat([pd.DataFrame(x_numerical), x_categorical], axis>=>1>).values> # Fitting Random Forest Regression to the dataset> regressor>=> RandomForestRegressor(n_estimators>=>10>, random_state>=>0>, oob_score>=>True>)> # Fit the regressor with x and y data> regressor.fit(x, y)> |
>
>
Stap 5: Maak voorspellingen en evaluatie
De code evalueert het getrainde Random Forest Regressie-model:
- out-of-bag (OOB)-score, die de generalisatieprestaties van het model schat.
- Maakt voorspellingen met behulp van het getrainde model en slaat deze op in de array ‘predictions’.
- Evalueert de prestaties van het model met behulp van de Mean Squared Error (MSE) en R-kwadraat (R2)-statistieken.
Out of Bag-score in RandomForest
Tasscore of OOB-score is het type validatietechniek dat voornamelijk wordt gebruikt in bagging-algoritmen om het bagging-algoritme te valideren. Hier wordt een klein deel van de validatiegegevens uit de hoofdstroom van de gegevens gehaald en worden de voorspellingen over de specifieke validatiegegevens gedaan en vergeleken met de andere resultaten.
Het belangrijkste voordeel dat de OOB-score biedt, is dat hier de validatiegegevens niet worden gezien door het oppakalgoritme en daarom zijn de resultaten op de OOB-score de echte resultaten die de daadwerkelijke prestaties van het oppakalgoritme aangeven.
Om de OOB-score van het specifieke Random Forest-algoritme te verkrijgen, moet men de waarde True instellen voor de parameter OOB_Score in het algoritme.
Python3
# Evaluating the model> from> sklearn.metrics>import> mean_squared_error, r2_score> # Access the OOB Score> oob_score>=> regressor.oob_score_> print>(f>'Out-of-Bag Score: {oob_score}'>)> # Making predictions on the same data or new data> predictions>=> regressor.predict(x)> # Evaluating the model> mse>=> mean_squared_error(y, predictions)> print>(f>'Mean Squared Error: {mse}'>)> r2>=> r2_score(y, predictions)> print>(f>'R-squared: {r2}'>)> |
>
>
Uitgang:
Out-of-Bag Score: 0.644879832593859 Mean Squared Error: 2647325000.0 R-squared: 0.9671801245316117>
Stap 6: Visualisatie
Laten we nu de resultaten visualiseren die zijn verkregen door het RandomForest Regressie-model te gebruiken op onze salarisdataset.
- Creëert een raster van voorspellingspunten die het bereik van de objectwaarden bestrijken.
- Tekent de echte gegevenspunten als blauwe spreidingspunten.
- Tekent de voorspelde waarden voor het voorspellingsraster als een groene lijn.
- Voegt labels en een titel toe aan de plot voor een beter begrip.
Python3
import> numpy as np> X_grid>=> np.arange(>min>(X),>max>(X),>0.01>)> X_grid>=> X_grid.reshape(>len>(X_grid),>1>)> > plt.scatter(X,y, color>=>'blue'>)>#plotting real points> plt.plot(X_grid, regressor.predict(X_grid),color>=>'green'>)>#plotting for predict points> > plt.title(>'Random Forest Regression Results'>)> plt.xlabel(>'Position level'>)> plt.ylabel(>'Salary'>)> plt.show()> |
>
>
Uitgang:
Stap 7: Visualisatie van een enkele beslissingsboom uit het Random Forest-model
De code visualiseert een van de beslissingsbomen uit het getrainde Random Forest-model. Tekent de geselecteerde beslissingsboom, waarbij het besluitvormingsproces van een enkele boom binnen het ensemble wordt weergegeven.
Python3
from> sklearn.tree>import> plot_tree> import> matplotlib.pyplot as plt> # Assuming regressor is your trained Random Forest model> # Pick one tree from the forest, e.g., the first tree (index 0)> tree_to_plot>=> regressor.estimators_[>0>]> # Plot the decision tree> plt.figure(figsize>=>(>20>,>10>))> plot_tree(tree_to_plot, feature_names>=>df.columns.tolist(), filled>=>True>, rounded>=>True>, fontsize>=>10>)> plt.title(>'Decision Tree from Random Forest'>)> plt.show()> |
>
>
Uitgang:
Toepassingen van willekeurige bosregressie
Toepassingen van willekeurige bosregressie De willekeurige bosregressie kent een breed scala aan problemen uit de echte wereld, waaronder:
- Continue numerieke waarden voorspellen: Voorspellen van huizenprijzen, aandelenkoersen of de levenslange klantwaarde.
- Risicofactoren identificeren: Het detecteren van risicofactoren voor ziekten, financiële crises of andere negatieve gebeurtenissen.
- Omgaan met hoogdimensionale gegevens: Analyseren van datasets met een groot aantal invoerfuncties.
- Complexe relaties vastleggen: Modelleren van complexe relaties tussen invoerkenmerken en de doelvariabele.
Voordelen van willekeurige bosregressie
- Het is gemakkelijk te gebruiken en minder gevoelig voor de trainingsgegevens in vergelijking met de beslisboom.
- Het is nauwkeuriger dan de beslissingsboom algoritme.
- Het is effectief bij het verwerken van grote datasets met veel attributen.
- Het kan ontbrekende gegevens verwerken, uitschieters en luidruchtige functies.
Nadelen van willekeurige bosregressie
- Het model kan ook moeilijk te interpreteren zijn.
- Dit algoritme vereist mogelijk enige domeinexpertise om de juiste parameters te kiezen, zoals het aantal beslissingsbomen, de maximale diepte van elke boom en het aantal kenmerken waarmee bij elke splitsing rekening moet worden gehouden.
- Het is computationeel duur, vooral voor grote datasets.
- Het kan er last van hebben overfitting als het model te complex is of het aantal beslisbomen te hoog is.
Conclusie
Random Forest Regressie is een krachtig hulpmiddel geworden voor continue voorspellingstaken, met voordelen ten opzichte van traditionele beslissingsbomen. De mogelijkheid om hoogdimensionale gegevens te verwerken, complexe relaties vast te leggen en overfitting te verminderen, heeft het tot een populaire keuze gemaakt voor een verscheidenheid aan toepassingen. De scikit-learn-bibliotheek van Python maakt de implementatie, optimalisatie en evaluatie van Random Forest Regression-modellen mogelijk, waardoor het een toegankelijke en effectieve techniek wordt voor beoefenaars van machine learning.
Veelgestelde vragen (FAQ's)
1. Wat is Random Forest Regressie Python?
Random Forest Regression Python is een ensemble-leermethode die meerdere beslissingsbomen gebruikt om voorspellingen te doen. Het is een krachtig en veelzijdig algoritme dat zeer geschikt is voor regressietaken.
for-lus in shell-script
2. Wat is het nut van willekeurige bosregressie?
Random Forest Regressie kan worden gebruikt om een verscheidenheid aan doelvariabelen te voorspellen, waaronder prijzen, verkopen, klantenverloop en meer. Het is een robuust algoritme dat niet gemakkelijk overmatig kan worden aangepast, waardoor het een goede keuze is voor toepassingen in de echte wereld.
3. Wat is het verschil tussen willekeurig forest en regressie?
Random Forest is een ensemble-leermethode, terwijl regressie een soort begeleid leeralgoritme is. Random Forest gebruikt meerdere beslissingsbomen om voorspellingen te doen, terwijl regressie één enkel model gebruikt om voorspellingen te doen.
4. Hoe stem je de hyperparameters van Random Forest Regressie af?
Er zijn verschillende methoden voor het afstemmen van de hyperparameters van Random Forest Regressie, zoals:
- Raster zoeken: Bij het zoeken in een raster worden systematisch verschillende combinaties van hyperparameterwaarden geprobeerd om de beste combinatie te vinden.
- Willekeurig zoeken: Willekeurig zoeken bemonstert willekeurig verschillende combinaties van hyperparameterwaarden om een goede combinatie te vinden.
5. Waarom is willekeurig bos beter dan regressie?
Random Forest is over het algemeen nauwkeuriger en robuuster dan regressie. Het is ook minder gevoelig voor overfitting, wat betekent dat het waarschijnlijker is om goed te generaliseren naar nieuwe gegevens.