Végleges útmutató a véletlenszerű erdőalgoritmushoz Python és Scikit-Learn segítségével

Bevezetés

A Random Forest algoritmus az egyik legrugalmasabb, leghatékonyabb és legszélesebb körben használt algoritmus osztályozás és regresszió, mint an határozati fák együttese.

Ha nem ismeri ezeket – ne aggódjon, mi ezeket a fogalmakat lefedjük.

Ebben a részletes gyakorlati útmutatóban egy intuíció arról, hogyan működnek a döntési fák, hogyan növeli az összeállítás az egyes osztályozókat és regresszorokat, mik azok a véletlenszerű erdők, és készítsen véletlenszerű erdőosztályozót és regresszort Python és Scikit-Learn segítségével, egy végpontok közötti miniprojekten keresztül, és válaszoljon egy kutatási kérdésre.

Gondolj arra, hogy jelenleg egy olyan kutatócsoport tagja vagy, amely a nőkre vonatkozó adatokat elemzi. A csoport 100 adatrekordot gyűjtött össze, és szeretné rendszerezni ezeket a kezdeti rekordokat oly módon, hogy a nőket kategóriákba osztja: terhes-e vagy nem, és vidéki vagy városi területeken él. A kutatók azt akarják megérteni, hogy hány nő lenne az egyes kategóriákban.

Van egy számítási struktúra, ami pontosan ezt teszi, ez a fa szerkezet. Egy fastruktúra használatával képes lesz az egyes kategóriák különböző felosztásait ábrázolni.

Döntési fák

Hogyan lehet feltölteni egy fa csomópontjait? Ez az, ahol döntési fák fókuszba kerüljön.

Először is feloszthatjuk a rekordokat terhesség szerint, ezt követően pedig városi vagy vidéki életvitel szerint. Vegyük észre, hogy ezt más sorrendben is megtehetnénk, először azzal osztva, hogy a nők milyen területen élnek, majd a terhességi állapotukkal. Ebből láthatjuk, hogy a fának van egy eredendő hierarchiája. A fa az információk rendszerezése mellett hierarchikusan is rendszerezi az információkat – az információ megjelenési sorrendje számít, és ennek eredményeként különböző fákhoz vezet.

Az alábbiakban egy példa a leírt fára:

A fa képén 7 négyzet látható, a tetején lévő, amely összesen 100 nőt jelent, ez a felső négyzet lent van összekötve két négyzettel, amelyek a nők száma alapján osztják el a 78 nem terhes és 22 terhes nőt, és mindkét előző négyzetből négy négyzet van; A fenti négyzetekhez kettő kapcsolódik, amelyek területük alapján osztják el a nőket, a nem terheseknél 45 lakik városi területen, 33 vidéken és a terheseknél, 14 vidéken és 8 városi területen. Ha ránézünk a fára, könnyen megérthetjük ezeket a felosztásokat, és láthatjuk, hogy az egyes „rétegek” hogyan származnak a korábbiakból, ezek a rétegek a fa. szintek, a szintek leírják a mélység a fáról:

Figyelje meg a fenti képen, hogy az első faszint az szinten 0 ahol csak egy négyzet van, ezt követi szinten 1 ahol két négyzet van, és szinten 2 ahol négy négyzet van. Ez egy mélység 2 fa.

A 0. szinten van a négyzet, amelyből a fa származik, az első, ún gyökércsomópont, ennek a gyökérnek kettő van gyermek csomópontok 1. szinten, vagyis szülő csomópontok Nézze meg, hogy az eddig említett „négyzetek” valójában ún. csomópontok; és minden előző csomópont szülője a következő csomópontoknak, amelyek a gyermekeik. Az egyes szintek gyermekcsomópontjait, amelyeknek ugyanaz a szülője, hívják testvérek, amint az a következő képen is látható:

Az előző képen az 1-es szintet is úgy jelenítjük meg, mint a belső csomópontok, miután a gyökér és az utolsó csomópontok között vannak, amelyek a levél csomópontok. A levélcsomók a fa utolsó részei, ha a 100 kezdeti nőből azt mondanánk, hányan vannak terhesek és vidéken élnek, akkor ezt a levelekre nézve megtehetnénk. Tehát a leveleken lévő szám válaszolna az első kutatási kérdésre.

Ha új feljegyzések születnének nőkről, és a korábban kategorizálásukra használt fát használnák most annak eldöntésére, hogy egy nő részt vehet-e a kutatásban vagy sem, akkor is működne? A fa ugyanazokat a kritériumokat alkalmazná, és egy nő is részt vehetne, ha terhes és vidéki területen élne.

A fenti képet nézve láthatjuk, hogy az egyes facsomópontok kérdéseire – „résztvevő?”, „terhes?”, „vidéken él?” – igen a válasz. igen, és igen, tehát úgy tűnik, hogy a fa gondolata elvezethet olyan döntéshez, ebben az esetben, hogy a nő részt vehet a kutatásban.

Ez a esszencia döntési fák, kézzel történik. A Machine Learning segítségével felállíthatunk egy olyan modellt, amely automatikusan elkészíti ezt a fát, így maximalizálja a végső döntések pontosságát.

Az előző példákban figyelje meg, hogy a fa hogyan tehette osztályoz új adatok résztvevőként vagy nem résztvevőként, illetve a kérdéseket is módosítani lehet a következőre: „hány résztvevő?”, „hányan terhesek?”, „hányan élnek vidéken?” – így megtaláljuk a mennyiség vidéken élő terhes résztvevők.

Az adatok besorolása azt jelenti, hogy a fa a besorolás feladatot, és ha az adatmennyiség megtalálható, a fa a regresszió feladat. Ez azt jelenti, hogy a döntési fa mindkét feladatra – osztályozásra és regresszióra – használható.

Most, hogy megértjük, mi az a döntési fa, hogyan használható, és milyen nómenklatúrával írják le, elgondolkodhatunk a korlátain.

A véletlenszerű erdők megértése

Mi történik a döntéssel, ha valamelyik résztvevő a városi és vidéki területek megosztottságán él? A fa hozzáadná ezt a rekordot a vidéki vagy a városi számhoz? Úgy tűnik, nehéz beilleszteni ezeket az adatokat a jelenlegi struktúránkba, mivel meglehetősen egyértelmű.

Továbbá, mi van akkor, ha egy hajón élő nő vesz részt a kutatásban, vidékinek vagy városinak minősül? Ugyanúgy, mint az előző esetnél, a fa rendelkezésre álló opcióinak figyelembevételével nehéz adatpontot jelent az osztályozás.

Ha egy kicsit jobban átgondoljuk a döntési fa példáját, láthatjuk, hogy képes helyesen osztályozni az új adatokat, tekintve, hogy azok már követik a fában már meglévő mintát – de ha vannak olyan rekordok, amelyek eltérnek a fát meghatározó kezdeti adatoktól, a fa szerkezete túl merev, így a rekordok nem osztályozhatók.

Ez azt jelenti, hogy a döntési fa szigorú és korlátozott lehet a lehetőségeiben. Egy ideális döntési fa rugalmasabb lenne, és árnyaltabb, nem látható adatokhoz is képes lenne hozzáférni.

A kiinduló kérdésre adott válasz kapcsán már tudjuk, hogy ez a falevelekben lesz kódolva – de mi változik, ha sok fa van egy helyett?

Ha a fákat egy osztályozáshoz kombináljuk, az eredményt a válaszok többsége határozza meg, ezt nevezzük többségi szavazással; regresszió esetén pedig az erdő egyes fái által megadott szám lesz átlagolt.

Együttes tanulás és modellegyüttesek

Ez a módszer az úgynevezett együttes tanulás. Az ensemble learning alkalmazásakor bármilyen algoritmust összekeverhet, feltéve, hogy a kimenet értelmezhető és kombinálható más kimenetekkel (akár manuálisan, akár meglévő könyvtárak használatával). Általában több, azonos típusú modellt, például több döntési fát együttesen állít össze, de nem korlátozódik az azonos modelltípusú együttesek összekapcsolására.

Az összeállítás gyakorlatilag garantált módja annak, hogy jobban általánosítsunk egy problémát, és kismértékben növeljük a teljesítményt. Egyes esetekben a modellek összeállítása a jelentős a prediktív erő növekedése, és néha csak kismértékben. Ez a betanított és értékelendő adatkészlettől, valamint maguktól a modellektől függ.

A döntési fák összekapcsolása hozamot eredményez jelentős teljesítménynövekedés az egyes fákhoz képest. Ezt a megközelítést népszerűsítették a kutatói és alkalmazott gépi tanulási közösségekben, és annyira elterjedt volt, hogy a döntési fák együttesét a köznyelvben elnevezték. erdő, és a kialakulóban lévő gyakori erdőtípus (döntési fák erdeje a jellemzők véletlenszerű részhalmazán) népszerűsítette a nevet véletlenszerű erdők.

A széleskörű használat miatt az olyan könyvtárak, mint a Scikit-Learn, wrappereket implementáltak a számára RandomForestRegressors és RandomForestClassifiers, amelyek a saját döntési fa implementációira épülnek, hogy a kutatók elkerülhessék saját együtteseik építését.

Merüljünk el a véletlenszerű erdőkben!

Hogyan működik a Random Forest Algoritmus?

A véletlenszerű erdőalgoritmus végrehajtásának alapvető lépései a következők:

1. Válasszon ki néhány véletlenszerű rekordot, ez tetszőleges szám lehet, például 4, 20, 76, 150 vagy akár 2.000 az adatkészletből (úgy nevezett N rekordok). A szám az adatkészlet szélességétől függ, minél szélesebb, annál nagyobb N lehet. Itt van a véletlen Az algoritmus nevének egy része innen származik!
2. Ezek alapján készítsen döntési fát N véletlenszerű rekordok;
3. Az algoritmushoz meghatározott fák számának vagy az erdőben lévő fák számának megfelelően ismételje meg az 1. és 2. lépést. Ez több fát generál véletlenszerű adatrekordokból;
4. A 3. lépés után következik az utolsó lépés, amely az eredmények előrejelzése:
   • Osztályozás esetén: az erdőben minden fa megjósolja, hogy melyik kategóriába tartozik az új rekord. Ezt követően az új rekordot a többségi szavazatot megnyerő kategóriához rendelik.
   • Regresszió esetén: az erdőben lévő minden fa megjósol egy értéket az új rekordhoz, és a végső előrejelzési érték az erdőben lévő összes fa által megjósolt összes érték átlagát véve számítja ki.

A jellemzők véletlenszerű részhalmazára illeszkedő fák szükségszerűen nem ismerik néhány más jellemzőt, amit az összeállítás javít, miközben a számítási költség alacsonyabb marad.

A fák működésével kapcsolatos intuícióval és a Random Forests megértésével – az egyetlen dolog, ami hátra van, csak gyakorolni kell az építkezést, a képzést és az adatokon való hangolást!

Véletlenszerű erdőmodellek készítése és betanítása a Scikit-Learn segítségével

Megvolt az oka annak, hogy az eddig használt példák terhességre, lakóterületre és nőkre vonatkoznak.

2020-ban bangladesi kutatók észrevették, hogy a terhes nők halálozási aránya még mindig nagyon magas, különös tekintettel a vidéki területeken élőkre. Emiatt IOT-figyelő rendszert használtak elemzi az anyák egészségének kockázatát. Az IOT-rendszer Banglades vidéki területeiről gyűjtött adatokat különböző kórházakról, közösségi klinikákról és anyai egészségügyi ellátásról.

Az összegyűjtött adatokat ezután egy vesszővel tagolt értékű (csv) fájlba rendezték, és feltöltötték ide Az UCI gépi tanulási tárháza.

Ezek azok az adatok, amelyeket arra fogunk használni, hogy gyakoroljuk és megpróbáljuk megérteni, ha egy terhes nőnek a alacsony, közepes or nagy halálozási kockázat.

Véletlenszerű erdő használata az osztályozáshoz

Mivel szeretnénk tudni, hogy a nőnek van-e a alacsony, közepes or nagy halálozási kockázat, ez azt jelenti, hogy három osztályba sorolunk. Ha egy feladatnak kettőnél több osztálya van, akkor a többosztályú probléma, szemben a kétkomponensű probléma (ahol általában két osztály közül választhat 0 és a 1).

Ebben az első példában egy többosztályos osztályozási modellt fogunk megvalósítani Random Forest osztályozóval és Python Scikit-Learn-el.

A probléma megoldásához a szokásos gépi tanulási lépéseket követjük, amelyek a könyvtárak betöltése, az adatok beolvasása, az összefoglaló statisztikák megtekintése és az adatvizualizációk létrehozása a jobb megértéshez. Ezután az adatok előfeldolgozása és felosztása, majd egy modell generálása, betanítása és kiértékelése.

Könyvtárak importálása

Az adatok kiolvasásához a Pandákat, a megjelenítéshez a Seabornt és a Matplotlibet, a nagyszerű segédmódszerekhez pedig a NumPy-t használjuk:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

Az adatkészlet importálása

A következő kód importálja az adatkészletet, és betölti egy pythonba DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Az adatok első öt sorának megtekintéséhez végrehajtjuk a head() parancs:

dataset.head()

Ez a következő kimenetet adja:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

Itt láthatjuk a kutatás során összegyűjtött összes attribútumot.

• Életkor: életkor években.
• Systolic BP: a vérnyomás felső értéke Hgmm-ben, ami jelentős tulajdonság a terhesség alatt.
• Diasztolés BP: a vérnyomás alacsonyabb értéke Hgmm-ben, egy másik jelentős tulajdonság a terhesség alatt.
• BS: vércukorszint moláris koncentrációban, mmol/l.
• HeartRate: nyugalmi pulzusszám percenkénti ütésben.
• RiskLevel: kockázati szint terhesség alatt.
• BodyTemp: a testhőmérséklet.

Most, hogy jobban megértjük, mit mérünk, megvizsgálhatjuk az adatok típusait info():

dataset.info()

Ennek eredményeként:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

Attól, hogy ránézek a RangeIndex sorban láthatjuk, hogy 1014 rekord van, és az oszlop Non-Null Count tájékoztat arról, hogy az adatokból nincsenek hiányzó értékek. Ez azt jelenti, hogy nem kell kezelnünk a hiányzó adatokat!

A Dtype oszlopban láthatjuk az egyes változók típusát. Jelenleg float64 oszlopok ilyenek BS és a BodyTemp számértékei bármely tartományban változhatnak, például 15.0, 15.51, 15.76, 17.28, így számszerűen folytonos (a lebegőpontos számhoz mindig hozzáadhat 0-t, ad infinitem). Másrészt olyan változók, mint pl Age, SystolicBP, DiastolicBPés HeartRate típusúak int64, ez azt jelenti, hogy a számok csak mértékegységenként változnak, például 11, 12, 13, 14 – nem lesz 77.78-as pulzusunk, hanem 77 vagy 78 – ezek számszerűen diszkrét értékeket. És nekünk is van RiskLevel val,-vel object típus, ez általában azt jelzi, hogy a változó egy szöveg, és valószínűleg számmá kell alakítanunk. Mivel a kockázati szint alacsonyról magasra növekszik, a kategóriákban van egy hallgatólagos sorrend, ami azt jelzi, hogy kategorikusan ordinális változót.

Az adattípusok megtekintése után használhatjuk describe() csúcsot venni néhány leíró statisztikánál, mint például az egyes oszlopok átlagértékei, a szórása, kvantilisai, minimális és maximális adatértékei:

dataset.describe().T 

A fenti kód a következőt jeleníti meg:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

Figyelje meg, hogy a legtöbb oszlop esetében a jelent értékek messze vannak a szórás (std) – ez azt jelzi, hogy az adatok nem feltétlenül követnek jól viselkedett statisztikai eloszlást. Ha igen, az segített volna a modellnek a kockázat előrejelzésében. Itt az adatok előfeldolgozása, hogy azok reprezentatívabbak legyenek, mintha a világ teljes népességének adatai lennének. normalizált. Ez azonban előny, ha Random Forest modelleket használ besorolás, az, hogy az inherens fastruktúra jól tud kezelni a nem normalizált adatokat, miután elosztja azokat az egyes változók faszintjei értékével.

Továbbá, mivel fákat használunk, és az eredményül kapott osztályt szavazással kapjuk meg, eredendően nem hasonlítjuk össze a különböző értékeket, csak az azonos típusú értékeket, így ebben az esetben nem szükséges a jellemzőket ugyanarra a skálára igazítani. . Ez azt jelenti, hogy a Random Forest osztályozási modell az skálainvariáns, és nem kell funkcióméretezést végrehajtania.

Ebben az esetben az adat-előfeldolgozás egyik lépése a kategorikus átalakítása RiskLevel oszlopot numerikussá.

Az adatok megjelenítése

Átalakítás előtt RiskLevel, gyorsan vizualizálhatjuk is az adatokat úgy, hogy megvizsgáljuk az egyes jellemzőpárok pontkombinációit egy Scatterplot segítségével, és hogyan oszlanak el a pontok a hisztogram görbe megjelenítésével. Ehhez a Seabornt használjuk pairplot() amely mindkét cselekményt egyesíti. Mindegyik jellemző kombinációhoz mindkét diagramot generálja, és a kockázati szintnek megfelelően színkódolva jeleníti meg a pontokat a hue ingatlan:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

A fenti kód a következőket generálja:

Ha a diagramot nézzük, az ideális helyzet az lenne, ha a görbék és a pontok egyértelműen elkülönülnének egymástól. Amint látjuk, a háromféle kockázati osztály többnyire keveredik, mivel a fák belülről vonalakat húznak a pontok közötti terek elhatárolásakor, így feltételezhető, hogy az erdőben több fa több teret korlátozhat és jobban osztályozhatja a pontokat.

Az alapvető feltáró adatelemzés elvégzésével elő tudjuk dolgozni a RiskLevel oszlop.

Adatok előfeldolgozása az osztályozáshoz

Az biztos, hogy csak három osztály létezik RiskLevel adatainkban, és hogy nem adtunk hozzá más értéket hibásan, használhatjuk unique() az oszlop egyedi értékeinek megjelenítéséhez:

dataset['RiskLevel'].unique()

Ez a következő kimenetet adja:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

Az osztályok ellenőrzése megtörtént, most a következő lépés az egyes értékek számmá alakítása. Mivel az osztályozások között sorrend van, a jelöléshez használhatjuk a 0, 1 és 2 értékeket alacsony, közepes és a nagy kockázatokat. Az oszlopértékek megváltoztatásának számos módja van a Python szerint az egyszerű jobb, mint az összetett mottója, használni fogjuk a .replace() metódust, és egyszerűen cserélje ki őket egész számokra:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

Az értékek cseréje után az adatokat feloszthatjuk arra, hogy a modell betanításához mire használjuk, a jellemzők or X, és amit meg akarunk jósolni, az címkék or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

Miután a X és a y készletek készen állnak, használhatjuk a Scikit-Learn-t train_test_split() módszer a vonat- és tesztkészletekre való további felosztására:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Itt az adatok 20%-át tesztelésre, 80%-át pedig edzésre használjuk.

RandomForestClassifier betanítása

A Scikit-Learn által megvalósított együttesek a sklearn.ensemble modult. Az osztályozáshoz használt döntési fák együttese, amelyben többségi szavazás történik, a RandomForestClassifier.

A vonat és a tesztkészletek birtokában importálhatjuk a RandomForestClassifier osztályt, és készítse el a modellt. Kezdésként hozzunk létre egy erdőt három fával, beállítással n_estimators paramétert 3-ra, és minden fának három szintje van, beállítással max_depth2-ig:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

Hogy a modellt az adatok köré illesszük – hívjuk a fit() módszer, a képzési jellemzők és címkék megadása:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Most összehasonlíthatjuk az előre jelzett címkéket a valós címkékkel, hogy értékeljük, milyen jól teljesített a modell! A modell értékelése előtt vessünk egy pillantást az együttesre.

Ha kicsit mélyebben bele akarunk nézni a modellbe, vizualizálhatjuk az egyes fákat és azt, hogy hogyan osztják fel az adatokat. Ezt a tree a Scikit-Learn-be épített modult, majd végigpörgeti az összes becslést az együttesben:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

A fenti kód a faterületeket jeleníti meg:

Figyeld meg, miben különbözik a három fa. Az első a BS funkció, a második -val DiastolicBP, a harmadik pedig BS újra. Bár a harmadik különböző számú mintát néz. A jobb oldali ágon az első két fa is dönt a használat mellett Age a levél szintjén, míg a harmadik fa ezzel végződik BS funkció. Mindössze három becsléssel világosan látható, hogy a felskálázás milyen gazdag, változatos reprezentációt ad a tudásról, amely sikeresen összevonható egy rendkívül pontos modellbe.

Minél több fa van az erdőben, annál változatosabb lehet a modell. Van értelme a hozamok csökkenésének, bár mivel sok fa illeszkedik a jellemzők egy véletlenszerű részhalmazához, lesz egy kevés hasonló fa, amelyek nem kínálnak sokféleséget az együttesben, és amelyek elkezdenek rendelkezni. túl sok szavazati jog és torzítja az együttest, hogy túl illeszkedjen a képzési adatkészlethez, ami sérti az érvényesítési halmaz általánosítását.

Korábban felmerült egy hipotézis arról, hogy több fa legyen, és hogyan javíthatja a modell eredményeit. Vessünk egy pillantást az eredményekre, készítsünk egy új modellt, és nézzük meg, hogy a hipotézis érvényes-e!

A RandomForestClassifier értékelése

A Scikit-Learn megkönnyíti az alapvonalak létrehozását azáltal, hogy a DummyClassifier, amely előrejelzéseket ad ki a beviteli funkciók használata nélkül (teljesen véletlenszerű kimenetek). Ha a modelled jobb, mint a DummyClassifier, néhány folyik a tanulás! A tanulás maximalizálása érdekében – automatikusan tesztelhet különféle hiperparamétereket az a RandomizedSearchCV or GridSearchCV. Amellett, hogy rendelkezik kiindulási értékkel, a modell teljesítményét számos mérőszám objektívje alapján is értékelheti.

Néhány hagyományos osztályozási mérőszám, amely az algoritmus értékelésére használható, a következők: pontosság, visszahívás, f1-pontszám, pontosság és zavaros mátrix. Íme egy rövid magyarázat mindegyikről:

1. Pontosság: amikor az a célunk, hogy megértsük, milyen helyes előrejelzési értékeket tartott helyesnek az osztályozónk. A pontosság elosztja a valódi pozitív értékeket a pozitívnak jósolt mintákkal;

$$
pontosság = töredék{szöveg{igaz pozitívumok}}{szöveg{igaz pozitívumok} + szöveg{hamis pozitívumok}}
$$

2. visszahívás: általában pontossággal együtt számítják ki, hogy megértsük, hány valódi pozitívumot azonosított az osztályozónk. A visszahívást úgy számítják ki, hogy a valódi pozitívumot elosztják bármivel, amit pozitívnak kellett volna megjósolni.

$$
visszahívás = töredék{szöveg{igaz pozitívumok}}{szöveg{igaz pozitívumok} + szöveg{hamis negatívok}}
$$

3. F1 pontszám: a kiegyensúlyozott ill harmonikus átlag pontosság és felidézés. A legalacsonyabb érték 0, a legmagasabb pedig 1. Amikor f1-score egyenlő 1-gyel, ez azt jelenti, hogy az összes osztályt helyesen jelezték előre – ezt nagyon nehéz valós adatokkal megszerezni (kivételek szinte mindig vannak).

$$
text{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

4. Zavart mátrix: amikor tudnunk kell, mennyi mintát vettünk helyesen vagy rosszul minden osztály. A helyes és helyesen megjósolt értékeket hívjuk igazi pozitívumok, azokat, amelyeket pozitívnak jósoltak, de nem voltak pozitívak, nevezzük hamis pozitív. Ugyanaz a nómenklatúra igaz negatívumok és a hamis negatívok negatív értékekhez használják;

5. Pontosság: azt írja le, hogy az osztályozónk hány jóslatot kapott. A legalacsonyabb pontossági érték 0, a legmagasabb pedig 1. Ezt az értéket általában megszorozzák 100-zal, hogy megkapják a százalékot:

$$
pontosság = frac{szöveg{helyes előrejelzések száma}}{szöveg{jóslatok teljes száma}}
$$

A következő szkript futtatásával importálhatja a szükséges könyvtárakat, és megnézheti az eredményeket:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

A kimenet így néz ki:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

Az osztályozási jelentésben figyelje meg, hogy a visszahívás magas, 0.89 a 0. osztálynál, mind a pontosság, mind a visszahívás magas a 2. osztályban, 0.74, 0.72 – és az 1. osztály esetében alacsony, különösen a visszahívás 0.17 és a pontosság 0.57 . A felidézés és a pontosság közötti kapcsolatot mindhárom osztály külön-külön megragadja a F1 pontszám, amely a felidézés és a pontosság harmonikus átlaga – a modell ezt teszi rendben a 0. osztálynak, elég rossz az 1. osztálynak és megfelelő a 2. osztálynak.

A modellnek nagyon nehéz dolga van az azonosítás során közepes kockázatú esetek.

A mindössze 3 fát tartalmazó véletlenszerű erdőosztályozónk által elért pontosság a következő 0.58 (58%) – ez azt jelenti, hogy az eredmények valamivel több mint felét teljesítette. Ez alacsony pontosság, és talán javítható több fa hozzáadásával.

Ha megnézzük a zavaros mátrixot, láthatjuk, hogy a legtöbb hiba az 52 közepes kockázatú rekord alacsony kockázatúként való besorolása során van, ami további betekintést ad az 1. osztály alacsony visszahívásába. Ez elfogult a közepes kockázatú betegek alacsony kockázatúként való besorolása felé. kockázatos betegek.

Egy másik dolog, amelyet ellenőrizni lehet, hogy még több betekintést nyerhessen, az az, hogy az osztályozó milyen jellemzőket vesz leginkább figyelembe az előrejelzés során. Ez egy fontos lépés, amelyet meg kell tenni magyarázható gépi tanulási rendszerek, és segít azonosítani és enyhíteni a torzítást a modellekben.

Ennek megtekintéséhez elérhetjük a feature_importances_ az osztályozó tulajdonsága. Ez megadja nekünk a százalékos listát, így hozzáférhetünk a feature_names_in_ tulajdonság az egyes jellemzők nevének lekéréséhez, adatkeretbe rendezéséhez, a legmagasabbtól a legalacsonyabbig történő rendezéséhez, és az eredmény ábrázolásához:

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

Figyelje meg, hogy az osztályozó leginkább a vércukor, akkor egy kis diasztolés nyomás, testhőmérséklet és csak egy kis életkor a döntés meghozatalához, ennek is köze lehet az 1. osztály alacsony visszahívásához, esetleg a közepes kockázatú adatokhoz olyan jellemzőkhöz, amelyek nem sokat figyelembe vett a modell. Megpróbálhat többet eljátszani a jellemzők fontosságával, hogy megvizsgálja ezt, és megnézheti, hogy a modell változásai hatással vannak-e a használt szolgáltatásokra, és azt is, hogy van-e szignifikáns kapcsolat egyes jellemzők és az előre jelzett osztályok között.

Végre itt az ideje, hogy létrehozzunk egy új modellt több fával, hogy megnézzük, hogyan befolyásolja az eredményeket. Hozzuk létre a rfc_ erdő 900 fával, 8 szinttel és ugyanazzal a maggal. Javulnak az eredmények?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

A mérőszámok kiszámítása és megjelenítése:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

Ez a következő kimenetet adja:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

Ez azt mutatja, hogy több fa és speciálisabb fák (magasabb szintek) hozzáadása hogyan javította mutatóinkat. Még mindig alacsony a visszahívásunk az 1. osztályhoz, de a pontosság most 74%. A magas kockázatú esetek besorolásakor az F1-pontszám 0.85, ami azt jelenti, hogy a magas kockázatú esetek könnyebben azonosíthatók az előző modell 0.73-hoz képest!

Egy mindennapi projektben fontosabb lehet a magas kockázatú esetek azonosítása, például a pontossághoz hasonló mérőszámmal, amely más néven érzékenység a statisztikákban. Próbálja meg módosítani a modell paramétereit, és figyelje meg az eredményeket.

Mostanáig átfogó képet kaptunk arról, hogy a Random Forest hogyan használható az adatok osztályozására – a következő részben ugyanazt az adatkészletet más módon használhatjuk, hogy megnézzük, hogyan jósol ugyanaz a modell regresszióval az értékeket.

Véletlenszerű erdők használata regresszióhoz

Ebben a részben azt tanulmányozzuk, hogyan használható egy Random Forest algoritmus regressziós problémák megoldására a Scikit-Learn segítségével. Az algoritmus megvalósításának lépései szinte megegyeznek az osztályozás lépéseivel, a modell típusa és az előrejelzett adatok típusa mellett – amelyek mostantól folytonos értékűek lesznek – az adatok előkészítésében csak egy eltérés van.

Mivel a regresszió azért történik számértékek – válasszunk egy számértéket az adatkészletből. Láttuk, hogy a besorolásnál fontos volt a vércukorszint, tehát más jellemzők alapján is kiszámíthatónak kell lennie (hiszen ha valamilyen tulajdonsággal korrelál, akkor az a tulajdonság is korrelál vele).

Az osztályozáshoz tett lépések után először importáljuk a könyvtárakat és ugyanazt az adatkészletet. Ha ezt már megtette az osztályozási modellnél, akkor kihagyhatja ezt a részt, és közvetlenül az adatok képzéshez való előkészítéséhez léphet.

Könyvtárak és adatok importálása

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Adatok előfeldolgozása regresszióhoz

Ez egy regressziós feladat, így az osztályok előrejelzése helyett az adathalmaz egyik numerikus oszlopát is megjósolhatjuk. Ebben a példában a BS oszlop előrejelzésre kerül. Ez azt jelenti, hogy a y adatok fognak tartalmazni vércukor adatokés X az adatok a vércukorszinten kívül az összes jellemzőt tartalmazni fogják. Elválasztása után a X és a y adatokkal feloszthatjuk a vonat- és teszthalmazokat:

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

RandomForestRegressor képzése

Most, hogy méreteztük az adatkészletünket, ideje betanítani az algoritmusunkat, hogy megoldja ezt a regressziós problémát, és egy kicsit változtassunk rajta – létrehozunk egy modellt 20 fával az erdőben, mindegyik 4 szinttel. Ehhez a következő kódot hajthatja végre:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

Az összes paraméter részletes leírását megtalálja RandomForestRegressor a hivatalos dokumentációban.

Mivel 20 fa megrajzolása és megnézése némi időt és odaadást igényel, csak az elsőt ábrázolhatjuk, hogy megnézzük, miben különbözik az osztályozófától:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

Figyelje meg, hogy a regressziós fa már rendelkezik egy értékkel az egyes csomópontokra eső adatokhoz. Ezek azok az értékek, amelyeket a 20 fa kombinálásakor átlagolunk. Az osztályozással végzett tevékenységünket követve a jellemzők fontosságát is ábrázolhatja, hogy megtudja, milyen változókat vesz jobban figyelembe a regressziós modell az értékek kiszámításakor.

Ideje továbblépni a gépi tanulási probléma megoldásának utolsó és utolsó lépésére, és értékelni az algoritmus teljesítményét!

A RandomForestRegressor értékelése

A regressziós problémák esetében az algoritmusok kiértékeléséhez használt mérőszámok az átlagos abszolút hiba (MAE), az átlagos négyzetes hiba (MSE) és a root mean squared error (RMSE).

1. Átlagos abszolút hiba (MAE): amikor a becsült értékeket kivonjuk a tényleges értékekből, megkapva a hibákat, összeadjuk a hibák abszolút értékeit és megkapjuk az átlagukat. Ez a mérőszám képet ad a modell minden egyes előrejelzésére vonatkozó általános hibáról, minél kisebb (közelebb a 0-hoz), annál jobb.

$$
mae = (frac{1}{n})sum_{i=1}^{n}bal | Aktuális – Megjósolt jog |
$$

2. Átlagos négyzetes hiba (MSE): hasonló a MAE metrikához, de négyzetre emeli a hibák abszolút értékét. Továbbá, mint a MAE esetében, minél kisebb vagy közelebb van a 0-hoz, annál jobb. Az MSE értéke négyzetes, hogy a nagy hibák még nagyobbak legyenek. Egy dologra nagyon oda kell figyelni, hogy általában nehezen értelmezhető a mérőszám az értékek nagysága miatt, valamint azért, mert nem azonos skálán vannak az adatokkal.

$$
mse = sum_{i=1}^{D}(Tényleges – előrejelzett)^2
$$

3. Root Mean Squared Error (RMSE): az MSE-vel felvetett értelmezési problémát úgy próbálja megoldani, hogy megkapja a végső értékének négyzetgyökét, így azt az adatok azonos egységeire méretezi vissza. Könnyebben értelmezhető és jó, ha a hibás adat tényleges értékét kell megjelenítenünk, illetve megjelenítenünk. Megmutatja, hogy az adatok mennyiben változhatnak, tehát ha 4.35-ös RMSE-vel rendelkezünk, akkor a modellünk hibázhat, mert 4.35-öt adott a tényleges értékhez, vagy 4.35-re volt szüksége a tényleges érték eléréséhez. Minél közelebb van a 0-hoz, annál jobb.

$$
rmse = sqrt{ sum_{i=1}^{D}(Tényleges – előrejelzett)^2}
$$

A három mérőszám bármelyikét használhatjuk összehasonlítani modellek (ha választanunk kell egyet). Ugyanazt a regressziós modellt összehasonlíthatjuk különböző argumentumértékekkel vagy különböző adatokkal, majd figyelembe vehetjük az értékelési mérőszámokat. Ez az úgynevezett hiperparaméter hangolás – a tanulási algoritmust befolyásoló hiperparaméterek hangolása és az eredmények megfigyelése.

A modellek közötti választás során általában a legkisebb hibával rendelkezők teljesítenek jobban. A modellek figyelésekor, ha a mutatók rosszabbodtak, akkor a modell korábbi verziója jobb volt, vagy az adatokban jelentős változás történt, hogy a modell rosszabbul teljesítsen, mint ahogyan teljesített.

A következő kóddal találhatja meg ezeket az értékeket:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

A kimenetnek a következőnek kell lennie:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

20 fánál a négyzetgyökér 1.75, ami alacsony, de még így is – a fák számának emelésével és a többi paraméterrel kísérletezve ez a hiba valószínűleg még kisebb lehet.

A Random Forest használatának előnyei

Mint minden algoritmusnak, ennek is vannak előnyei és hátrányai. A következő két részben áttekintjük a véletlenszerű erdők osztályozáshoz és regresszióhoz való használatának előnyeit és hátrányait.

1. A véletlenszerű erdőalgoritmus nem torzított, mivel több fa létezik, és mindegyik fa az adatok véletlenszerű részhalmazára van tanítva. Alapvetően a véletlenszerű erdő algoritmus a „tömeg” erejére támaszkodik; ezért az algoritmus általános torzítási foka csökken.
2. Ez az algoritmus nagyon stabil. Még ha új adatpont kerül is be az adatkészletbe, az algoritmust nem érinti nagy mértékben, mivel az új adatok egy fára is hatással lehetnek, de nagyon nehéz az összes fára.
3. A véletlenszerű erdő algoritmus jól működik, ha kategorikus és numerikus jellemzőkkel is rendelkezik.
4. A véletlenszerű erdő algoritmus akkor is jól működik, ha az adatokból hiányoznak az értékek, vagy nincs méretezve.

A Random Forest használatának hátrányai

1. A véletlenszerű erdők fő hátránya összetettségükben rejlik. Sokkal több számítási erőforrást igényelnek a nagyszámú összeillesztett döntési fa miatt, amikor nagy együtteseket tanítanak. Bár – modern hardverrel még egy nagy, véletlenszerű erdő betanítása sem vesz igénybe sok időt.

Tovább haladva – Kézi, végpontokig projekt

Érdeklődő természete arra készteti, hogy tovább menjen? Javasoljuk, hogy tekintse meg nálunk Irányított projekt: „Hands-On House Price Prediction – gépi tanulás Pythonban”.

Ebben az irányított projektben megtudhatja, hogyan építhet hatékony hagyományos gépi tanulási modelleket, valamint mély tanulási modelleket, hogyan használhatja az Ensemble Learning-et és képezheti a metatanulókat a lakásárak előrejelzésére a Scikit-Learn és Keras modellek zsákjából.

A Keras, a Tensorflow-ra épülő mélytanulási API használatával architektúrákkal kísérletezzünk, halmozott modellek együttesét építjük fel, és megtanítunk egy meta-tanuló neurális hálózat (1. szintű modell) egy ház árának meghatározásához.

A mélyreható tanulás csodálatos – de mielőtt hozzáfognánk, tanácsos megpróbálni egyszerűbb technikákkal is megoldani a problémát, mint pl. sekély tanulás algoritmusok. Alapteljesítményünk a Véletlenszerű erdei regresszió algoritmus. Ezen kívül – megvizsgáljuk a modellegyüttesek létrehozását a Scikit-Learn segítségével olyan technikák segítségével, mint pl zsákolás és a szavazás.

Ez egy teljes körű projekt, és mint minden gépi tanulási projekt, mi is azzal kezdjük, hogy – azzal Feltáró adatelemzés, Ezt követi Adat előfeldolgozása és végül Sekély épület és a Mély tanulási modellek hogy illeszkedjenek a korábban feltárt és megtisztított adatokhoz.