Random Forest Regression er en allsidig maskinlæringsteknikk for å forutsi numeriske verdier. Den kombinerer spådommene fra flere beslutningstrær for å redusere overtilpasning og forbedre nøyaktigheten. Python maskinlæring biblioteker gjør det enkelt å implementere og optimalisere denne tilnærmingen.
Ensemble læring
Ensemblelæring er en maskinlæringsteknikk som kombinerer spådommene fra flere modeller for å skape en mer nøyaktig og stabil prediksjon. Det er en tilnærming som utnytter den kollektive intelligensen til flere modeller for å forbedre den generelle ytelsen til læringssystemet.
Typer ensemblemetoder
Det finnes ulike typer ensemblelæringsmetoder, inkludert:
- Bagging (Bootstrap Aggregating): Denne metoden innebærer å trene flere modeller på tilfeldige delmengder av treningsdataene. Prediksjonene fra de enkelte modellene kombineres deretter, typisk ved gjennomsnittsberegning.
- Forsterkning: Denne metoden innebærer å trene en sekvens av modeller, der hver påfølgende modell fokuserer på feilene som ble gjort av den forrige modellen. Spådommene er kombinert ved hjelp av en vektet stemmeordning.
- Stabling: Denne metoden innebærer å bruke spådommene fra ett sett med modeller som inputfunksjoner for en annen modell. Den endelige prediksjonen gjøres av modellen på andre nivå.
Tilfeldig skog
En tilfeldig skog er en ensemblelæringsmetode som kombinerer spådommene fra flere beslutningstrær for å produsere en mer nøyaktig og stabil prediksjon. Det er en type overvåket læringsalgoritme som kan brukes til både klassifiserings- og regresjonsoppgaver.
Hver beslutningstre har høy varians, men når vi kombinerer dem alle parallelt, er den resulterende variansen lav ettersom hvert beslutningstre blir perfekt trent på de aktuelle prøvedataene, og derfor avhenger ikke utdataene av ett beslutningstre, men av flere beslutningstre. I tilfelle av et klassifiseringsproblem, tas det endelige resultatet ved å bruke majoritetsstemmeklassifikatoren. Ved et regresjonsproblem er den endelige utgangen gjennomsnittet av alle utdataene. Denne delen kalles Aggregasjon .

Tilfeldig skogregresjonsmodell fungerer
Hva er tilfeldig skogregresjon?
Tilfeldig skogregresjon i maskinlæring er en teknisk sett i stand til å utføre begge deler regresjon og klassifisering oppgaver med bruk av flere beslutningstrær og en teknikk kalt Bootstrap and Aggregation, ofte kjent som bagging . Den grunnleggende ideen bak dette er å kombinere flere beslutningstrær for å bestemme det endelige resultatet i stedet for å stole på individuelle beslutningstrær.
Random Forest har flere beslutningstrær som grunnleggende læringsmodeller. Vi utfører tilfeldig radprøvetaking og funksjonsprøvetaking fra datasettet som danner prøvedatasett for hver modell. Denne delen kalles Bootstrap.
Vi må nærme oss Random Forest-regresjonsteknikken som alle andre maskinlæring teknikk.
- Design et spesifikt spørsmål eller data og få kilden til å bestemme de nødvendige dataene.
- Sørg for at dataene er i et tilgjengelig format, ellers konverter dem til ønsket format.
- Spesifiser alle merkbare anomalier og manglende datapunkter som kan være nødvendige for å oppnå de nødvendige dataene.
- Lag en maskinlæringsmodell.
- Angi grunnmodellen du ønsker å oppnå
- Tren datamaskinlæringsmodellen.
- Gi et innblikk i modellen med testdata
- Sammenlign nå ytelsesberegningene for både testdataene og de predikerte dataene fra modellen.
- Hvis det ikke tilfredsstiller forventningene dine, kan du prøve å forbedre modellen din tilsvarende eller datere dataene dine, eller bruke en annen datamodelleringsteknikk.
- På dette stadiet tolker du dataene du har fått og rapporterer deretter.
Tilfeldig skogregresjon i Python
Vi vil bruke en lignende prøveteknikk i eksemplet nedenfor. Nedenfor er et trinn-for-trinn eksempel på implementering av Random Forest Regression, på datasettet som kan lastes ned her- https://bit.ly/417n3N5
Python biblioteker gjør det veldig enkelt for oss å håndtere dataene og utføre typiske og komplekse oppgaver med en enkelt kodelinje.
- Pandaer – Dette biblioteket hjelper til med å laste inn datarammen i et 2D-array-format og har flere funksjoner for å utføre analyseoppgaver på én gang.
- Numpy – Numpy-matriser er veldig raske og kan utføre store beregninger på veldig kort tid.
- Matplotlib / Seaborn – Dette biblioteket brukes til å tegne visualiseringer.
- Sklearn – Denne modulen inneholder flere biblioteker med forhåndsimplementerte funksjoner for å utføre oppgaver fra dataforbehandling til modellutvikling og evaluering.
- RandomForestRegressor – Dette er regresjonsmodellen som er basert på Random Forest-modellen eller ensemblelæringen som vi skal bruke i denne artikkelen ved å bruke sklearn-biblioteket.
- lære: Dette biblioteket er kjernebiblioteket for maskinlæring i Python. Det gir et bredt spekter av verktøy for forbehandling, modellering, evaluering og distribusjon av maskinlæringsmodeller.
- LabelEncoder: Denne klassen brukes til å kode kategoriske data til numeriske verdier.
- KNNInputer: Denne klassen brukes til å imputere manglende verdier i et datasett ved å bruke en k-nærmeste nabo-tilnærming.
- train_test_split: Denne funksjonen brukes til å dele et datasett i trenings- og testsett.
- StandardScaler: Denne klassen brukes til å standardisere funksjoner ved å fjerne gjennomsnittet og skalere til enhetsvarians.
- f1_score: Denne funksjonen brukes til å evaluere ytelsen til en klassifiseringsmodell ved å bruke F1-poengsummen.
- RandomForestRegressor: Denne klassen brukes til å trene en tilfeldig skogregresjonsmodell.
- cross_val_score: Denne funksjonen brukes til å utføre k-fold kryssvalidering for å evaluere ytelsen til en modell
Trinn-1: Importer biblioteker
Her importerer vi alle nødvendige biblioteker.
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'>)> |
>
>
Trinn-2: Importer datasett
La oss nå laste inn datasettet i pandaens dataramme. For bedre datahåndtering og utnyttelse av de praktiske funksjonene for å utføre komplekse oppgaver på én gang.
slett filen i java
Python3
df>=> pd.read_csv(>'Salaries.csv'>)> print>(df)> |
>
>
Produksjon:
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>
Her er.info()>metoden gir en rask oversikt over strukturen, datatypene og minnebruken til datasettet.
Python3
df.info()> |
>
>
Produksjon:
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>
Trinn-3: Dataforberedelse
Her vil koden trekke ut to delsett av data fra datasettet og lagre dem i separate variabler.
- Uttrekksfunksjoner: Den trekker ut funksjonene fra DataFrame og lagrer dem i en variabel kalt
X>. - Trekker ut målvariabel: Den trekker ut målvariabelen fra DataFrame og lagrer den i en variabel kalt
y>.
Python3
# Assuming df is your DataFrame> X>=> df.iloc[:,>1>:>2>].values>#features> y>=> df.iloc[:,>2>].values># Target variable> |
>
lykke til
>
Trinn-4: Random Forest Regressor Model
Koden behandler kategoriske data ved å kode dem numerisk, kombinerer de behandlede dataene med numeriske data, og trener en Random Forest Regression-modell ved å bruke de forberedte dataene.
Python3
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)> |
>
>
Trinn-5: Lag spådommer og evaluering
Koden evaluerer den trente modellen for Random Forest Regression:
- out-of-bag (OOB) poengsum, som estimerer modellens generaliseringsytelse.
- Gjør spådommer ved å bruke den trente modellen og lagrer dem i «prediksjons»-arrayen.
- Evaluerer modellens ytelse ved å bruke beregningene Mean Squared Error (MSE) og R-squared (R2).
Ut av bag-score i RandomForest
"hva er forskjellen mellom en løve og en tiger"
Bag score eller OOB-score er typen valideringsteknikk som hovedsakelig brukes i bagging-algoritmer for å validere bagging-algoritmen. Her er en liten del av valideringsdataene hentet fra hovedstrømmen av dataene og prediksjonene på de aktuelle valideringsdataene blir gjort og sammenlignet med de andre resultatene.
Den største fordelen som OOB-poengsummen gir er at her ikke valideringsdataene blir sett av bagging-algoritmen, og det er derfor resultatene på OOB-poengsummen er de sanne resultatene som indikerte den faktiske ytelsen til bagging-algoritmen.
For å få OOB-poengsummen til den bestemte Random Forest-algoritmen, må man angi verdien True for OOB_Score-parameteren i algoritmen.
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}'>)> |
>
>
Produksjon:
Out-of-Bag Score: 0.644879832593859 Mean Squared Error: 2647325000.0 R-squared: 0.9671801245316117>
Trinn-6: Visualisering
La oss nå visualisere resultatene oppnådd ved å bruke RandomForest-regresjonsmodellen på lønnsdatasettet vårt.
- Oppretter et rutenett med prediksjonspunkter som dekker området til funksjonsverdiene.
- Plotter de virkelige datapunktene som blå spredningspunkter.
- Plotter de anslåtte verdiene for prediksjonsnettet som en grønn linje.
- Legger til etiketter og en tittel til plottet for bedre forståelse.
Python3
pyspark veiledning
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()> |
>
>
Produksjon:

Trinn-7: Visualisere et enkelt beslutningstre fra Random Forest Model
Koden visualiserer et av beslutningstrærene fra den trente Random Forest-modellen. Plotter det valgte beslutningstreet, og viser beslutningsprosessen til et enkelt tre i ensemblet.
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()> |
>
>
Produksjon:
Anvendelser av tilfeldig skogregresjon
Den tilfeldige skogregresjonen har et bredt spekter av virkelige problemer, inkludert:
- Forutsi kontinuerlige numeriske verdier: Forutsi boligpriser, aksjekurser eller livstidsverdi for kunder.
- Identifisering av risikofaktorer: Å oppdage risikofaktorer for sykdommer, økonomiske kriser eller andre negative hendelser.
- Håndtering av høydimensjonale data: Analysere datasett med et stort antall inndatafunksjoner.
- Fange komplekse relasjoner: Modellering av komplekse forhold mellom inputfunksjoner og målvariabelen.
Fordeler med tilfeldig skogregresjon
- Den er enkel å bruke og mindre følsom for treningsdataene sammenlignet med beslutningstreet.
- Det er mer nøyaktig enn beslutningstre algoritme.
- Det er effektivt for å håndtere store datasett som har mange attributter.
- Den kan håndtere manglende data, uteliggere , og støyende funksjoner.
Ulemper ved tilfeldig skogregresjon
- Modellen kan også være vanskelig å tolke.
- Denne algoritmen kan kreve litt domeneekspertise for å velge de riktige parameterne som antall beslutningstrær, maksimal dybde til hvert tre og antall funksjoner som skal vurderes ved hver splitt.
- Det er beregningsmessig dyrt, spesielt for store datasett.
- Det kan lide av overmontering hvis modellen er for kompleks eller antallet beslutningstrær er for høyt.
Konklusjon
Random Forest Regression har blitt et kraftig verktøy for kontinuerlige prediksjonsoppgaver, med fordeler fremfor tradisjonelle beslutningstrær. Dens evne til å håndtere høydimensjonale data, fange komplekse relasjoner og redusere overtilpasning har gjort det til et populært valg for en rekke bruksområder. Pythons scikit-learn-bibliotek muliggjør implementering, optimalisering og evaluering av Random Forest Regression-modeller, noe som gjør det til en tilgjengelig og effektiv teknikk for maskinlæringsutøvere.
Ofte stilte spørsmål (FAQ)
1. Hva er Random Forest Regression Python?
Random Forest Regression Python er en ensemblelæringsmetode som bruker flere beslutningstrær for å lage spådommer. Det er en kraftig og allsidig algoritme som er godt egnet for regresjonsoppgaver.
2. Hva er bruken av tilfeldig skogregresjon?
Tilfeldig skogregresjon kan brukes til å forutsi en rekke målvariabler, inkludert priser, salg, kundeavgang og mer. Det er en robust algoritme som ikke lett overmonteres, noe som gjør den til et godt valg for virkelige applikasjoner.
3. Hva er forskjellen mellom tilfeldig skog og regresjon?
Random Forest er en ensemblelæringsmetode, mens regresjon er en type overvåket læringsalgoritme. Random Forest bruker flere beslutningstrær for å lage spådommer, mens regresjon bruker en enkelt modell for å lage spådommer.
4. Hvordan justerer du hyperparametrene til Random Forest Regression?
Det er flere metoder for å justere hyperparametrene til Random Forest Regression, for eksempel:
- Rutenettsøk: Rutenettsøk innebærer systematisk å prøve forskjellige kombinasjoner av hyperparameterverdier for å finne den beste kombinasjonen.
- Tilfeldig søk: Tilfeldig søk prøver tilfeldig ulike kombinasjoner av hyperparameterverdier for å finne en god kombinasjon.
5. Hvorfor er tilfeldig skog bedre enn regresjon?
Random Forest er generelt mer nøyaktig og robust enn regresjon. Det er også mindre utsatt for overtilpasning, noe som betyr at det er mer sannsynlig å generalisere godt til nye data.
Anvendelser av tilfeldig skogregresjon