Random Forest Regression är en mångsidig maskininlärningsteknik för att förutsäga numeriska värden. Den kombinerar förutsägelserna från flera beslutsträd för att minska överanpassning och förbättra noggrannheten. Python maskininlärning bibliotek gör det enkelt att implementera och optimera detta tillvägagångssätt.
Ensemble Learning
Ensemble learning är en maskininlärningsteknik som kombinerar förutsägelser från flera modeller för att skapa en mer exakt och stabil förutsägelse. Det är ett tillvägagångssätt som utnyttjar den kollektiva intelligensen hos flera modeller för att förbättra inlärningssystemets övergripande prestanda.
Typer av ensemblemetoder
Det finns olika typer av ensembleinlärningsmetoder, inklusive:
- Bagage (Bootstrap Aggregating): Denna metod involverar träning av flera modeller på slumpmässiga delmängder av träningsdata. Förutsägelserna från de individuella modellerna kombineras sedan, vanligtvis genom medelvärde.
- Boost: Denna metod innebär att man tränar en sekvens av modeller, där varje efterföljande modell fokuserar på de fel som gjorts av den tidigare modellen. Förutsägelserna kombineras med hjälp av ett viktat röstsystem.
- Stapling: Denna metod innebär att man använder förutsägelser från en uppsättning modeller som indatafunktioner för en annan modell. Den slutliga förutsägelsen görs av modellen på andra nivån.
Random Forest
En slumpmässig skog är en ensembleinlärningsmetod som kombinerar förutsägelser från flera beslutsträd för att producera en mer exakt och stabil förutsägelse. Det är en typ av övervakad inlärningsalgoritm som kan användas för både klassificerings- och regressionsuppgifter.
Varje beslutsträd har hög varians, men när vi kombinerar dem alla parallellt är den resulterande variansen låg eftersom varje beslutsträd blir perfekt tränat på just den provdatan, och därför beror utdata inte på ett beslutsträd utan på flera beslutsträd. I fallet med ett klassificeringsproblem tas slutresultatet med användning av majoritetsröstningsklassificeraren. I fallet med ett regressionsproblem är slutresultatet medelvärdet av alla utdata. Denna del kallas Aggregation .

Random Forest Regression Model Working
Vad är Random Forest Regression?
Random Forest Regression i maskininlärning är en teknisk uppsättning kapabla att utföra båda regression och klassificering uppgifter med användning av flera beslutsträd och en teknik som kallas Bootstrap and Aggregation, allmänt känd som säckväv . Grundtanken bakom detta är att kombinera flera beslutsträd för att bestämma slutresultatet snarare än att förlita sig på individuella beslutsträd.
Random Forest har flera beslutsträd som basinlärningsmodeller. Vi utför slumpmässigt radsampling och funktionssampling från datauppsättningen som bildar provdatauppsättningar för varje modell. Denna del kallas Bootstrap.
Vi måste närma oss Random Forest-regressionstekniken som alla andra maskininlärning Metod.
- Designa en specifik fråga eller data och få källan för att avgöra vilken data som krävs.
- Se till att data är i ett tillgängligt format, annars konvertera det till önskat format.
- Ange alla märkbara anomalier och saknade datapunkter som kan behövas för att uppnå de nödvändiga uppgifterna.
- Skapa en maskininlärningsmodell.
- Ställ in den baslinjemodell du vill uppnå
- Träna datamaskininlärningsmodellen.
- Ge en inblick i modellen med testdata
- Jämför nu prestandamåtten för både testdata och predikterade data från modellen.
- Om den inte uppfyller dina förväntningar kan du försöka förbättra din modell i enlighet med detta eller datera din data, eller använda en annan datamodelleringsteknik.
- I detta skede tolkar du den data du har fått och rapporterar därefter.
Random Forest Regression i Python
Vi kommer att använda en liknande provteknik i exemplet nedan. Nedan är ett steg-för-steg exempel på implementering av Random Forest Regression, på datasetet som kan laddas ner här- https://bit.ly/417n3N5
Pytonorm bibliotek gör det mycket enkelt för oss att hantera data och utföra typiska och komplexa uppgifter med en enda kodrad.
- Pandas – Det här biblioteket hjälper till att ladda dataramen i ett 2D-matrisformat och har flera funktioner för att utföra analysuppgifter på en gång.
- Numpy – Numpy-arrayer är mycket snabba och kan utföra stora beräkningar på mycket kort tid.
- Matplotlib / Seaborn – Det här biblioteket används för att rita visualiseringar.
- Sklearn – Denna modul innehåller flera bibliotek med förimplementerade funktioner för att utföra uppgifter från dataförbehandling till modellutveckling och utvärdering.
- RandomForestRegressor – Det här är regressionsmodellen som är baserad på Random Forest-modellen eller den ensembleinlärning som vi kommer att använda i den här artikeln med hjälp av sklearn-biblioteket.
- lära dig: Detta bibliotek är kärnbiblioteket för maskininlärning i Python. Den tillhandahåller ett brett utbud av verktyg för förbearbetning, modellering, utvärdering och implementering av maskininlärningsmodeller.
- LabelEncoder: Denna klass används för att koda kategoriska data till numeriska värden.
- KNNInmatare: Denna klass används för att imputera saknade värden i en datauppsättning med hjälp av en k-närmaste grannar-metod.
- train_test_split: Denna funktion används för att dela upp en datauppsättning i tränings- och testuppsättningar.
- StandardScaler: Den här klassen används för att standardisera funktioner genom att ta bort medelvärdet och skala till enhetsvarians.
- f1_score: Denna funktion används för att utvärdera prestandan för en klassificeringsmodell med hjälp av F1-poängen.
- RandomForestRegressor: Denna klass används för att träna en slumpmässig skogsregressionsmodell.
- cross_val_score: Denna funktion används för att utföra k-faldig korsvalidering för att utvärdera prestandan hos en modell
Steg-1: Importera bibliotek
Här importerar vi alla nödvändiga bibliotek som krävs.
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'>)> |
>
>
Steg-2: Importera datauppsättning
Låt oss nu ladda datauppsättningen i pandans dataram. För bättre datahantering och utnyttjande av de praktiska funktionerna för att utföra komplexa uppgifter på en gång.
markdown med bilder
Python3
df>=> pd.read_csv(>'Salaries.csv'>)> print>(df)> |
>
>
Produktion:
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>
Här.info()>metod ger en snabb översikt över strukturen, datatyperna och minnesanvändningen för datamängden.
Python3
df.info()> |
>
>
Produktion:
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>
Steg 3: Dataförberedelse
Här kommer koden att extrahera två delmängder av data från datamängden och lagra dem i separata variabler.
- Extraherande funktioner: Den extraherar funktionerna från DataFrame och lagrar dem i en variabel som heter
X>. - Extrahera målvariabel: Den extraherar målvariabeln från DataFrame och lagrar den i en variabel med namnet
y>.
Python3
# Assuming df is your DataFrame> X>=> df.iloc[:,>1>:>2>].values>#features> y>=> df.iloc[:,>2>].values># Target variable> |
>
bfs-sökning
>
Steg-4: Random Forest Regressor Model
Koden behandlar kategorisk data genom att koda den numeriskt, kombinerar den bearbetade datan med numerisk data och tränar en Random Forest Regression-modell med hjälp av den förberedda datan.
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)> |
>
>
Steg-5: Gör förutsägelser och utvärdering
Koden utvärderar den tränade Random Forest Regression-modellen:
- out-of-bag (OOB) poäng, som uppskattar modellens generaliseringsprestanda.
- Gör förutsägelser med hjälp av den tränade modellen och lagrar dem i 'förutsägelser'-arrayen.
- Utvärderar modellens prestanda med hjälp av mätvärdena Mean Squared Error (MSE) och R-squad (R2).
Out of Bag-poäng i RandomForest
Väska poäng eller OOB-poäng är den typ av valideringsteknik som främst används i säckalgoritmer för att validera säckalgoritmen. Här hämtas en liten del av valideringsdata från huvudströmmen av datan och förutsägelserna om den specifika valideringsdatan görs och jämförs med de andra resultaten.
Den största fördelen som OOB-poängen erbjuder är att valideringsdata här inte ses av säckalgoritmen och det är därför resultaten på OOB-poängen är de sanna resultaten som indikerar den faktiska prestandan för säckalgoritmen.
För att få OOB-poängen för den specifika Random Forest-algoritmen måste man ställa in värdet True för parametern OOB_Score 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}'>)> |
>
linux mint cinnamon vs mate
>
Produktion:
Out-of-Bag Score: 0.644879832593859 Mean Squared Error: 2647325000.0 R-squared: 0.9671801245316117>
Steg-6: Visualisering
Låt oss nu visualisera resultaten som erhålls genom att använda RandomForest-regressionsmodellen på vår lönesuppsättning.
- Skapar ett rutnät med förutsägelsepunkter som täcker området för funktionsvärdena.
- Ritar de verkliga datapunkterna som blå spridningspunkter.
- Ritar de förutsagda värdena för prediktionsrutnätet som en grön linje.
- Lägger till etiketter och en titel till handlingen för bättre förståelse.
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()> |
>
>
Produktion:

Steg-7: Visualisera ett enda beslutsträd från Random Forest Model
Koden visualiserar ett av beslutsträden från den tränade Random Forest-modellen. Ritar det valda beslutsträdet och visar beslutsprocessen för ett enskilt träd inom ensemblen.
Python3
dolda appar
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()> |
>
>
Produktion:
Tillämpningar av Random Forest Regression
Den slumpmässiga skogsregressionen har ett brett utbud av verkliga problem, inklusive:
- Förutsäga kontinuerliga numeriska värden: Förutsäga huspriser, aktiekurser eller kundens livstidsvärde.
- Identifiera riskfaktorer: Upptäcka riskfaktorer för sjukdomar, finansiella kriser eller andra negativa händelser.
- Hantera högdimensionell data: Analysera datamängder med ett stort antal indatafunktioner.
- Fånga komplexa relationer: Modellera komplexa samband mellan indatafunktioner och målvariabeln.
Fördelar med Random Forest Regression
- Den är lätt att använda och mindre känslig för träningsdata jämfört med beslutsträdet.
- Det är mer exakt än beslutsträd algoritm.
- Det är effektivt för att hantera stora datamängder som har många attribut.
- Den kan hantera saknad data, extremvärden , och bullriga funktioner.
Nackdelar med Random Forest Regression
- Modellen kan också vara svårtolkad.
- Denna algoritm kan kräva viss domänexpertis för att välja lämpliga parametrar som antalet beslutsträd, det maximala djupet för varje träd och antalet funktioner som ska beaktas vid varje delning.
- Det är beräkningsmässigt dyrt, särskilt för stora datamängder.
- Det kan drabbas av överanpassning om modellen är för komplex eller antalet beslutsträd är för högt.
Slutsats
Random Forest Regression har blivit ett kraftfullt verktyg för kontinuerliga prediktionsuppgifter, med fördelar jämfört med traditionella beslutsträd. Dess förmåga att hantera högdimensionella data, fånga komplexa relationer och minska överanpassning har gjort det till ett populärt val för en mängd olika applikationer. Pythons scikit-learn-bibliotek möjliggör implementering, optimering och utvärdering av Random Forest Regression-modeller, vilket gör det till en tillgänglig och effektiv teknik för utövare av maskininlärning.
Vanliga frågor (FAQ)
1. Vad är Random Forest Regression Python?
Random Forest Regression Python är en ensembleinlärningsmetod som använder flera beslutsträd för att göra förutsägelser. Det är en kraftfull och mångsidig algoritm som är väl lämpad för regressionsuppgifter.
2. Vad är användningen av slumpmässig skogsregression?
Random Forest Regression kan användas för att förutsäga en mängd olika målvariabler, inklusive priser, försäljning, kundavgång och mer. Det är en robust algoritm som inte lätt övermonteras, vilket gör den till ett bra val för verkliga tillämpningar.
3. Vad är skillnaden mellan slumpmässig skog och regression?
Random Forest är en ensembleinlärningsmetod, medan regression är en typ av övervakad inlärningsalgoritm. Random Forest använder flera beslutsträd för att göra förutsägelser, medan regression använder en enda modell för att göra förutsägelser.
4. Hur ställer du in hyperparametrarna för Random Forest Regression?
Det finns flera metoder för att ställa in hyperparametrarna för Random Forest Regression, till exempel:
- Rutnätssökning: Rutnätssökning innebär att man systematiskt provar olika kombinationer av hyperparametervärden för att hitta den bästa kombinationen.
- Slumpmässig sökning: Slumpmässig sökning tar slumpmässigt urval av olika kombinationer av hyperparametervärden för att hitta en bra kombination.
5. Varför är random skog bättre än regression?
Random Forest är i allmänhet mer exakt och robust än regression. Det är också mindre benäget att överanpassa, vilket innebär att det är mer benäget att generalisera väl till nya data.
Tillämpningar av Random Forest Regression