Juhusliku metsaalgoritmi lõplik juhend Pythoni ja Scikit-Learniga

Sissejuhatus

Random Foresti algoritm on üks paindlikumaid, võimsamaid ja laialdasemalt kasutatavaid algoritme klassifikatsioon ja regressioon, ehitatud an otsustuspuude ansambel.

Kui te pole nendega tuttav – ärge muretsege, me käsitleme kõiki neid mõisteid.

Selles põhjalikus praktilises juhendis koostame intuitsioon selle kohta, kuidas otsustuspuud töötavad, kuidas komplekteerimine võimendab üksikuid klassifikaatoreid ja regressoreid, mis on juhuslikud metsad, koostage Pythoni ja Scikit-Learni abil juhuslik metsaklassifikaator ja regressor, kasutades täielikku miniprojekti ning vastake uurimisküsimusele.

Mõelge, et kuulute praegu naiste kohta käivaid andmeid analüüsivasse uurimisrühma. Rühm on kogunud 100 andmekirjet ja soovib, et oleks võimalik neid esialgseid kirjeid korraldada, jagades naised kategooriatesse: rasedad või mitte ning elavad maal või linnas. Teadlased tahavad mõista, kui palju naisi oleks igas kategoorias.

On olemas arvutuslik struktuur, mis teeb täpselt seda, see on puu struktuur. Puustruktuuri kasutades saate esindada iga kategooria erinevaid jaotisi.

Otsustuspuud

Kuidas asustada puu sõlmpunkte? See on koht otsustuspuud fookusesse sattuda.

Esiteks saame kirjed jagada raseduse järgi, pärast seda saame need jagada linnas või maal elamise järgi. Pange tähele, et me võiksime seda teha erinevas järjekorras, jagades algselt naiste elupiirkonna ja raseduse seisuga. Sellest näeme, et puul on omane hierarhia. Lisaks teabe korrastamisele korraldab puu teavet hierarhiliselt – info ilmumise järjekord on oluline ja viib selle tulemusena erinevate puudeni.

Allpool on näide kirjeldatud puust:

Puupildil on 7 ruutu, ülemine ruutu, mis moodustab kokku 100 naist, see ülemine ruut on ühendatud kahe allpool oleva ruuduga, mis jagavad naised nende arvu järgi, mis on 78 mitteraseda ja 22 raseda. mõlemast eelmisest ruudust on neli ruutu; kaks on ühendatud iga ülaltoodud ruuduga, mis jagavad naised nende pindala alusel, mitterasedate puhul 45 elab linnas, 33 maal ja rasedate jaoks, 14 elab maal ja 8 linnas. Lihtsalt puud vaadates on lihtne mõista neid jaotusi ja näha, kuidas iga "kiht" on tuletatud eelmistest, need kihid on puu taset, tasemed kirjeldavad sügavus puust:

Jälgige ülaloleval pildil, et esimene puu tase on tasandil 0 kus on ainult üks ruut, millele järgneb tasandil 1 kus on kaks ruutu ja tasandil 2 kus on neli ruutu. See on sügavus 2 puu.

Tasemel 0 on ruut, millest puu alguse saab, esimene, mida nimetatakse juursõlm, sellel juurel on kaks lapse sõlmed 1. tasemel, see tähendab vanemsõlmed 2. taseme neljale sõlmele. Vaadake, et "ruudud", mida me seni mainisime, on tegelikult nn. sõlmed; ja et iga eelmine sõlm on järgmiste sõlmede, mis on selle lapsed, vanem. Kutsutakse välja iga taseme alamsõlmed, millel on sama vanem õed-vennad, nagu on näha järgmisel pildil:

Eelmisel pildil kuvame ka 1. taseme kui sisemised sõlmed, kui need on juure ja viimaste sõlmede vahel, mis on lehtede sõlmed. Lehesõlmed on puu viimane osa, kui 100 esialgse naise põhjal öelda, kui paljud on rasedad ja elavad maapiirkondades, saaksime seda teha lehti vaadates. Nii et number lehtedel vastaks esimesele uurimisküsimusele.

Kui naiste kohta oleks uusi rekordeid ja puu, mida varem kasutati nende kategoriseerimiseks, kasutataks nüüd selleks, et otsustada, kas naine võib uuringus osaleda või mitte, kas see siis ikkagi toimiks? Puu kasutaks samu kriteeriume ja naine oleks osalemiskõlblik, kui rase ja elab maapiirkonnas.

Ülaltoodud pilti vaadates näeme, et vastused iga puusõlme küsimustele – “kas ta on osaleja?”, “Kas ta on rase?”, “Kas ta elab maapiirkonnas?” – on jaatavad, jah, ja jah, seega tundub, et puu võib viia otsuseni, antud juhul, et naine võiks uuringus osaleda.

See on essenss otsustuspuudest, tehakse käsitsi. Masinõppe abil saame koostada mudeli, mis koostab selle puu meie jaoks automaatselt, et maksimeerida lõplike otsuste täpsust.

Eelmistes näidetes jälgige, kuidas puu võiks kumbagi klassifitseerima uued andmed, kas osaleja või mitteosaleja või küsimusi saab muuta ka järgmisteks: "Kui palju on osalejaid?", "Kui paljud on rasedad?", "Kui paljud elavad maapiirkonnas?", mis viib meid üles kogus rasedatest osalejatest, kes elavad maapiirkonnas.

Kui andmed on salastatud, tähendab see, et puu täidab a klassifikatsioon ülesanne ja kui andmete hulk on leitud, täidab puu a regressioon ülesanne. See tähendab, et otsustuspuud saab kasutada mõlema ülesande jaoks – klassifitseerimiseks ja regressiooniks.

Nüüd, kui me mõistame, mis on otsustuspuu, kuidas seda kasutada ja millist nomenklatuuri selle kirjeldamiseks kasutatakse, võime mõelda selle piirangute üle.

Juhuslike metsade mõistmine

Mis saab otsusest, kui mõni osaleja elab linna- ja maapiirkondade jaotusest? Kas puu lisaks selle rekordi maale või linnale? Tundub, et neid andmeid on raske sobitada praegusesse struktuuri, kuna see on üsna selge.

Samuti, mis siis, kui uuringus osaleb naine, kes elab paadis, kas seda peetakse maal või linnas? Sarnaselt eelmisele juhtumile on puus saadaolevaid valikuid arvestades keeruline andmepunkt klassifitseerida.

Otsustuspuu näitele pisut lähemalt mõeldes näeme, et see suudab uued andmed õigesti klassifitseerida, arvestades, et need järgivad juba puul juba olemasolevat mustrit, kuid kui on kirjeid, mis erinevad puu määratlenud algandmetest, puu struktuur on liiga jäik, mistõttu kirjeid ei saa klassifitseerida.

See tähendab, et otsustuspuu võib olla range ja piiratud oma võimalustega. Ideaalne otsustuspuu oleks paindlikum ja suudab mahutada nüansirikkamaid nähtamatuid andmeid.

Mis puutub vastusesse esialgsele küsimusele, siis me juba teame, et see kodeeritakse puulehtedesse – aga mis muutub, kui meil on ühe puude asemel palju?

Kui puud on klassifikatsiooni jaoks kombineeritud, määrab tulemuse enamik vastuseid, seda nimetatakse häälteenamusega; ja regressiooni korral on iga metsa puu poolt antud arv keskmistatud.

Ansambliõpe ja mudeliansamblid

Seda meetodit tuntakse kui ansambliõpe. Ansambelõppe kasutamisel saate kombineerida mis tahes algoritme, kui saate tagada, et väljundit saab sõeluda ja kombineerida teiste väljunditega (kas käsitsi või olemasolevaid teeke kasutades). Tavaliselt ühendate mitu sama tüüpi mudelit koos (nt mitu otsustuspuud), kuid te ei piirdu ainult sama mudeli tüüpi ansamblite ühendamisega.

Koostamine on praktiliselt garanteeritud viis probleemile paremini üldistada ja jõudlusele kerget tõuget välja pigistada. Mõnel juhul annab mudelite komplekteerimine a märkimisväärne ennustamisvõime suurenemine ja mõnikord veidi. See sõltub andmestikust, mida treenite ja hindate, ning mudelitest endist.

Otsustuspuude ühendamine annab saagi märkimisväärne üksikute puudega võrreldes. Seda lähenemist populariseeriti teadusuuringute ja rakenduslike masinõppe kogukondades ning see oli nii levinud, et otsustuspuude ansambel nimetati kõnekeeles metsja levinud metsatüüp, mis loodi (otsustuspuude mets juhuslike tunnuste alamhulga peal) populariseeris nime juhuslikud metsad.

Arvestades laiaulatuslikku kasutamist, on sellised raamatukogud nagu Scikit-Learn kasutusele võtnud ümbrised RandomForestRegressors ja RandomForestClassifiers, mis on ehitatud nende endi otsustuspuu rakendustele, et võimaldada teadlastel vältida oma ansamblite ehitamist.

Sukeldume suvalistesse metsadesse!

Kuidas juhuslik metsaalgoritm töötab?

Juhusliku metsa algoritmi täitmisel on järgmised põhietapid:

1. Valige hulk juhuslikke kirjeid, see võib olla mis tahes arv, näiteks 4, 20, 76, 150 või isegi 2.000 andmekogumist (nn. N rekordid). Arv sõltub andmestiku laiusest, mida laiem, seda suurem N võib olla. See on koht, kus juhuslik osa algoritmi nimest pärineb!
2. Ehitage nende põhjal otsustuspuu N juhuslikud kirjed;
3. Vastavalt algoritmi jaoks määratud puude arvule või puude arvule metsas korrake samme 1 ja 2. See genereerib juhuslike andmekirjete komplektidest rohkem puid;
4. Pärast 3. sammu tuleb viimane samm, milleks on tulemuste ennustamine:
   • Klassifikatsiooni puhul: iga puu metsas ennustab, millisesse kategooriasse uus rekord kuulub. Pärast seda määratakse uus rekord kategooriasse, mis võidab enamuse hääle.
   • Regressiooni korral: iga metsas olev puu ennustab uue rekordi väärtuse ja lõplik ennustusväärtus arvutatakse kõigi metsa puude prognoositud väärtuste keskmisena.

Iga puu, mis sobib juhuslikule funktsioonide alamhulgale, ei tea tingimata mõnest muust funktsioonist, mis parandatakse komplekteerimisega, hoides samal ajal arvutuskulud madalamad.

Puude toimimise intuitsiooni ja juhuslike metsade mõistmisega – jääb üle vaid harjutada nende ehitamist, treenimist ja andmete põhjal häälestamist!

Juhuslike metsamudelite loomine ja koolitamine Scikit-Learniga

Oli põhjust, miks seni kasutatud näited hõlmavad rasedust, eluruumi ja naisi.

2020. aastal märkasid Bangladeshi teadlased, et rasedate naiste suremus oli endiselt väga kõrge, eriti arvestades maapiirkondades elavaid naisi. Seetõttu kasutasid nad selleks IOT-seiresüsteemi analüüsida riske ema tervisele. IOT-süsteem kogus andmeid erinevatest Bangladeshi maapiirkondade haiglatest, kogukonnakliinikutest ja emade tervishoiuteenustest.

Seejärel korraldati kogutud andmed komadega eraldatud väärtusega (csv) faili ja laaditi üles UCI masinõppehoidla.

Neid andmeid kasutame praktikas ja proovime mõista, kas rasedal naisel on a madal, keskmine or suur suremuse risk.

Juhusliku metsa kasutamine klassifitseerimiseks

Kuna me tahame teada, kas naisel on a madal, keskmine or suur suremusrisk, see tähendab, et klassifitseerime kolme klassi. Kui probleemil on rohkem kui kaks klassi, nimetatakse seda a mitmeklassiline probleem, erinevalt a binaarne probleem (tavaliselt valite kahe klassi vahel 0 ja 1).

Selles esimeses näites rakendame mitme klassi klassifitseerimismudelit Random Foresti klassifikaatori ja Pythoni Scikit-Learniga.

Selle probleemi lahendamiseks järgime tavalisi masinõppe samme, milleks on teekide laadimine, andmete lugemine, kokkuvõtliku statistika vaatamine ja andmete visualiseerimise loomine, et seda paremini mõista. Seejärel andmete eeltöötlemine ja tükeldamine, millele järgneb mudeli genereerimine, koolitamine ja hindamine.

Raamatukogude importimine

Andmete lugemiseks kasutame Pandasid, nende visualiseerimiseks Seaborni ja Matplotlibi ning suurepäraste utiliidimeetodite jaoks NumPyt:

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

Andmestiku importimine

Järgmine kood impordib andmestiku ja laadib selle pythonisse DataFrame:

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

Andmete esimese viie rea vaatamiseks käivitame head() käsk:

dataset.head()

See annab väljundi:

    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

Siin näeme kõiki uurimistöö käigus kogutud atribuute.

• Vanus: vanused aastates.
• Süstoolne BP: vererõhu ülemine väärtus mmHg, oluline omadus raseduse ajal.
• Diastoolne BP: madalam vererõhu väärtus mmHg, teine ​​oluline omadus raseduse ajal.
• BS: vere glükoosisisaldus molaarse kontsentratsioonina, mmol/l.
• Heart Rate: südame löögisagedus puhkeolekus löökides minutis.
• RiskLevel: riskitase raseduse ajal.
• BodyTemp: kehatemperatuur.

Nüüd, kui saame mõõdetavast rohkem aru, saame vaadata andmete tüüpe info():

dataset.info()

Selle tulemuseks on:

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

Alates vaadates RangeIndex real, näeme, et seal on 1014 kirjet ja veerg Non-Null Count teatab, et andmetel ei ole puuduvaid väärtusi. See tähendab, et me ei pea puuduvate andmete puhul midagi ette võtma!

aasta Dtype veerus näeme iga muutuja tüüpi. Praegu float64 veerud nagu BS ja BodyTemp neil on arvväärtused, mis võivad mis tahes vahemikus varieeruda, nt 15.0, 15.51, 15.76, 17.28, muutes need arvuliselt pidev (ujukomaarvule saab alati lisada 0, ad infinitem). Teisest küljest on sellised muutujad nagu Age, SystolicBP, DiastolicBPja HeartRate on tüüpi int64, see tähendab, et numbrid muutuvad ainult ühikute kaupa, näiteks 11, 12, 13, 14 – meil ei ole pulss 77.78, see on kas 77 või 78 – need on numbriliselt diskreetne väärtused. Ja meil on ka RiskLevel koos object tüüpi, näitab see tavaliselt, et muutuja on tekst ja tõenäoliselt peame selle arvuks teisendama. Kuna riskitase kasvab madalast kõrgeni, on kategooriates kaudne järjekord, mis näitab, et see on kategooriliselt ordinaalne muutuja.

Pärast andmetüüpide vaatamist saame kasutada describe() et saada tipp mõnes kirjeldavas statistikas, nagu iga veeru keskmised väärtused, standardhälve, kvantilid, minimaalsed ja maksimaalsed andmeväärtused:

dataset.describe().T 

Ülaltoodud kood kuvab:

            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

Pange tähele, et enamiku veergude puhul on keskmine väärtused on sellest kaugel standardhälve (std) – see näitab, et andmed ei pruugi järgida hästi käitunud statistilist jaotust. Kui see nii oleks, oleks see mudelit riski ennustamisel aidanud. Siin saab andmeid eeltöötleda, et muuta need esinduslikumaks, nagu oleksid need andmed kogu maailma rahvastiku või enama kohta. normaliseeritud. Kuid see on eelis Random Foresti mudelite kasutamisel klassifikatsioon, on see, et loomupärane puustruktuur saab hästi hakkama andmetega, mida pole normaliseeritud, kui see jagab need iga muutuja iga puutaseme väärtusega.

Kuna me kasutame puid ja et tulemuseks olev klass saadakse hääletamise teel, ei võrdle me loomupäraselt erinevaid väärtusi, vaid ainult sama tüüpi väärtusi, seega ei ole antud juhul vajalike tunnuste kohandamine samale skaalale . See tähendab, et Random Forest klassifikatsioonimudel on skaala invariantja te ei pea funktsiooni skaleerima.

Sellisel juhul on andmete eeltöötluse samm kategooria teisendamine RiskLevel veerg numbriliseks.

Andmete visualiseerimine

Enne ümberkujundamist RiskLevel, visualiseerime ka andmed kiiresti, vaadates hajuvusdiagrammi abil iga tunnuspaari punktide kombinatsioone ja histogrammi kõvera visualiseerimise kaudu, kuidas punktid jaotuvad. Selleks kasutame Seaborni oma pairplot() mis ühendab mõlemad süžeed. See loob iga funktsioonikombinatsiooni jaoks mõlemad graafikud ja kuvab punktid värvikoodiga vastavalt nende riskitasemele hue Vara:

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

Ülaltoodud kood genereerib:

Graafiku vaadates oleks ideaalne olukord kõverate ja punktide selge eraldamine. Nagu näeme, on kolme tüüpi riskiklassid enamasti segamini, kuna puud tõmbavad punktidevahelisi ruume piiritledes sisemiselt jooned, siis võib oletada, et rohkem puid metsas suudaks rohkem ruume piirata ja punkte paremini klassifitseerida.

Kui põhiline uurimuslik andmete analüüs on tehtud, saame eeltöödelda RiskLevel kolonni.

Andmete eeltöötlus klassifitseerimiseks

Et olla kindel, on ainult kolm klassi RiskLevel meie andmetes ja muid väärtusi pole ekslikult lisatud, saame kasutada unique() veeru kordumatute väärtuste kuvamiseks:

dataset['RiskLevel'].unique()

See annab väljundi:

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

Klassid on kontrollitud, nüüd on järgmine samm iga väärtuse teisendamine arvuks. Kuna klassifikatsioonide vahel on järjekord, saame tähistamiseks kasutada väärtusi 0, 1 ja 2 madal, keskmine ja suur riske. Veeru väärtuste muutmiseks on Pythoni järgi palju võimalusi lihtne on parem kui keeruline moto, me kasutame .replace() meetodit ja asendage need lihtsalt nende täisarvudega:

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

Pärast väärtuste asendamist saame jagada andmed mudeli treenimiseks kasutatavateks Omadused or X, ja mida me tahame ennustada, sildid or y:

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

Kui X ja y komplektid on valmis, saame kasutada Scikit-Learni train_test_split() meetod nende edasiseks jagamiseks rongi- ja katsekomplektideks:

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)

Siin kasutame 20% andmetest testimiseks ja 80% koolituseks.

RandomForestClassifieri koolitamine

Scikit-Learni rakendatud ansamblid all sklearn.ensemble moodul. Klassifitseerimiseks kasutatav otsustuspuude ansambel, milles võetakse vastu häälteenamus, on realiseeritud kui RandomForestClassifier.

Kui meil on rong ja katsekomplektid, saame importida RandomForestClassifier klassi ja luua mudel. Alustuseks loome kolme puuga metsa sättimise teel n_estimators parameetriks 3 ja igal puul on kolm taset max_depthet 2:

from sklearn.ensemble import RandomForestClassifier

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

Mudeli sobitamiseks andmete ümber – nimetame fit() meetod, sisestades treeningfunktsioonid ja sildid:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Nüüd saame võrrelda ennustatud silte tegelike siltidega, et hinnata, kui hästi mudelil läks! Enne mudeli hindamist heidame pilgu ansamblisse.

Mudelisse pisut sügavamale vaatamiseks saame visualiseerida iga puud ja seda, kuidas nad andmeid jagavad. Seda saab teha kasutades tree Scikit-Learni sisseehitatud moodul ja seejärel silmused läbi ansambli iga hindaja:

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

Ülaltoodud kood kuvab puutükid:

Pange tähele, kuidas need kolm puud erinevad. Esimene algab tähega BS funktsioon, teine ​​koos DiastolicBP, ja kolmas koos BS uuesti. Kuigi kolmas vaatleb erinevat arvu proove. Paremal oksal otsustavad kasutamise ka kaks esimest puud Age lehtede tasemel, samas kui kolmas puu lõpeb BS tunnusjoon. Vaid kolme hinnanguga on selge, kuidas suurendamine annab rikkaliku ja mitmekesise esituse teadmistest, mida saab edukalt koondada ülitäpseks mudeliks.

Mida rohkem puid metsas, seda mitmekesisem võib mudel olla. Siiski on mõtet tootlus väheneda, kuid kuna paljud puud mahuvad juhuslikele tunnuste alamhulkadele, leidub üsna palju sarnaseid puid, mis ei paku ansamblis palju mitmekesisust ja millel hakkab olema liiga palju hääleõigust ja kallutada ansamblit treeningandmete kogumile liiga sobivaks, kahjustades valideerimiskomplekti üldistamist.

Varem püstitati hüpotees rohkemate puude olemasolu kohta ja selle kohta, kuidas see võiks mudeli tulemusi parandada. Vaatame tulemusi, loome uue mudeli ja vaatame, kas hüpotees kehtib!

RandomForestClassifieri hindamine

Scikit-Learn muudab lähtejoonte loomise lihtsaks, pakkudes a DummyClassifier, mis väljastab ennustusi sisendfunktsioone kasutamata (täiesti juhuslikud väljundid). Kui teie mudel on parem kui DummyClassifier, mõned õppimine toimub! Õppimise maksimeerimiseks – saate erinevaid hüperparameetreid automaatselt testida, kasutades a RandomizedSearchCV or GridSearchCV. Lisaks baasjoone olemasolule saate oma mudeli toimivust hinnata mitme mõõdiku objektiivi põhjal.

Mõned traditsioonilised klassifitseerimismõõdikud, mida saab kasutada algoritmi hindamiseks, on täpsus, meeldetuletus, f1-skoor, täpsus ja segadusmaatriks. Siin on nende kõigi kohta lühike selgitus:

1. Täpsus: kui meie eesmärk on mõista, milliseid õigeid ennustusväärtusi meie klassifikaator õigeks pidas. Täpsus jagab need tõelised positiivsed väärtused proovidega, mida ennustati positiivseteks;

$$
täpsus = frac{tekst{tõelised positiivsed}}{tekst{tõelised positiivsed} + tekst{valepositiivsed}}
$$

2. Tagasikutsumine: arvutatakse tavaliselt koos täpsusega, et mõista, kui palju tõelisi positiivseid omadusi meie klassifikaator tuvastas. Tagasikutsumine arvutatakse, jagades tõelised positiivsed väärtused kõigega, mida oleks pidanud positiivseks ennustama.

$$
meenutamine = frac{tekst{tõelised positiivsed}}{tekst{tõelised positiivsed} + tekst{valedegatiivsed}}
$$

3. F1 skoor: on tasakaalustatud või harmooniline keskmine täpsusest ja meeldejätmisest. Väikseim väärtus on 0 ja kõrgeim on 1. Millal f1-score on võrdne 1-ga, see tähendab, et kõik klassid olid õigesti ennustatud – seda on reaalsete andmetega väga raske saada (erandeid on peaaegu alati).

$$
tekst{f1-skoor} = 2* frac{tekst{täpsus} * tekst{taaskutsumine}}{tekst{täpsus} + tekst{taaskutsumine}}
$$

4. Segadusmaatriks: kui me peame teadma, kui palju proove saime õigesti või valesti iga klass. Väärtused, mis olid õiged ja õigesti ennustatud, nimetatakse tõelised positiivsed küljed, nimetatakse neid, mis olid positiivsed, kuid ei olnud positiivsed valepositiivsed. Sama nomenklatuur tõelised negatiivsed ja valenegatiivid kasutatakse negatiivsete väärtuste jaoks;

5. Täpsus: kirjeldab, kui palju ennustusi meie klassifikaator õigesti tegi. Väikseim täpsusväärtus on 0 ja kõrgeim on 1. Tavaliselt korrutatakse see väärtus 100-ga, et saada protsent:

$$
täpsus = frac{tekst{õigete ennustuste arv}}{tekst{ennustuste koguarv}}
$$

Vajalike teekide importimiseks ja tulemuste vaatamiseks saate käivitada järgmise skripti:

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

Väljund näeb välja umbes selline:

                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

Jälgige klassifikatsiooniaruandes, et tagasikutsumine on kõrge, 0.89 klassi 0 puhul, nii täpsus kui ka tagasikutsumine on kõrged klassis 2, 0.74, 0.72 – ja klassi 1 puhul on need madalad, eriti tagasikutsumine 0.17 ja täpsus 0.57 . Meenutamise ja täpsuse suhe kõigi kolme klassi puhul eraldi on jäädvustatud F1 skoor, mis on meenutamise ja täpsuse harmooniline keskmine – mudel teeb korras 0 klassi jaoks, 1 klassi jaoks üsna halb ja 2 klassi jaoks korralik.

Mudelil on selle tuvastamisel väga raske keskmise riskiga juhtumid.

Meie juhusliku metsaklassifikaatoriga saavutatud täpsus on ainult 3 puuga 0.58 (58%) – see tähendab, et natuke rohkem kui pooled tulemused on õiged. See on madal täpsus ja võib-olla saaks seda parandada, lisades rohkem puid.

Segadusmaatriksit vaadates näeme, et enamik vigu on 52 keskmise riskiga kirje klassifitseerimisel madala riskiga, mis annab täiendava ülevaate 1. klassi madalast tagasivõtmisest. See kaldub klassifitseerima keskmise riskiga patsiendid madala riskiga patsientide hulka. riskiga patsiendid.

Veel üks asi, mida saab kontrollida, et saada veelgi rohkem teavet, on see, milliseid funktsioone klassifikaator ennustamisel kõige enam arvesse võtab. See on oluline samm, mida teha seletatavad masinõppesüsteemidning aitab tuvastada ja leevendada mudelite eelarvamusi.

Selle nägemiseks pääseme juurde feature_importances_ klassifikaatori omadus. See annab meile protsentide loendi, et saaksime juurde pääseda feature_names_in_ atribuut, et saada iga funktsiooni nimi, korraldada need andmeraamis, sortida need kõrgeimast madalaimani ja joonistada tulemus:

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)

Pange tähele, kuidas klassifikaator võtab enamasti arvesse Veresuhkur, siis pisut diastoolset rõhku, kehatemperatuuri ja veidi vanust, et otsus langetada. See võib olla seotud ka 1. klassi madala tagasikutsumisega, võib-olla on keskmise riskiga andmed seotud funktsioonidega, mida ei kasutata. mida mudel palju arvesse võtab. Selle uurimiseks võite proovida rohkem mängida funktsioonide tähtsusega ja vaadata, kas mudeli muudatused mõjutavad kasutatavaid funktsioone, samuti seda, kas mõne funktsiooni ja prognoositud klasside vahel on oluline seos.

Lõpuks on aeg luua uus mudel, millel on rohkem puid, et näha, kuidas see tulemusi mõjutab. Loome rfc_ mets, kus on 900 puud, 8 tasapinda ja sama seeme. Kas tulemused paranevad?

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

Mõõdikute arvutamine ja kuvamine:

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

See annab väljundi:

                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

See näitab, kuidas rohkemate puude ja spetsiaalsemate puude (kõrgemad tasemed) lisamine on meie mõõdikuid parandanud. Meil on endiselt madal tagasikutsumine 1. klassi jaoks, kuid täpsus on nüüd 74%. F1-skoor kõrge riskiga juhtumite klassifitseerimisel on 0.85, mis tähendab, et kõrge riskiga juhtumeid on nüüd lihtsam tuvastada, võrreldes eelmise mudeli 0.73-ga!

Igapäevases projektis võib olulisem olla kõrge riskiga juhtumite tuvastamine, näiteks täpsusega sarnase mõõdiku abil, mida tuntakse ka kui tundlikkus statistikas. Proovige mõnda mudeli parameetrit kohandada ja jälgige tulemusi.

Siiani oleme saanud üldise arusaama sellest, kuidas Random Foresti saab andmete klassifitseerimiseks kasutada – järgmises jaotises saame kasutada sama andmekogumit erineval viisil, et näha, kuidas sama mudel ennustab regressiooniga väärtusi.

Juhuslike metsade kasutamine regressiooniks

Selles jaotises uurime, kuidas saab Scikit-Learni abil regressiooniprobleemide lahendamiseks kasutada Random Foresti algoritmi. Selle algoritmi rakendamiseks järgitavad sammud on peaaegu identsed klassifitseerimise etappidega, lisaks mudeli tüübile ja prognoositud andmete tüübile - mis on nüüd pidevad väärtused - andmete ettevalmistamisel on ainult üks erinevus.

Kuna regressioon on tehtud arvväärtusi – valime andmekogumist numbrilise väärtuse. Oleme näinud, et veresuhkur oli klassifikatsioonis oluline, seega peaks see olema muude tunnuste põhjal prognoositav (kuna kui see korreleerub mõne tunnusega, korreleerub see ka sellega).

Pärast seda, mida oleme klassifitseerimiseks teinud, impordime esmalt teegid ja sama andmestiku. Kui olete seda klassifitseerimismudeli jaoks juba teinud, võite selle osa vahele jätta ja minna otse andmete ettevalmistamise juurde koolituseks.

Teekide ja andmete importimine

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

Andmete eeltöötlus regressiooniks

See on regressiooniülesanne, nii et klasside ennustamise asemel saame ennustada üht andmestiku arvulist veergu. Selles näites on BS veergu ennustatakse. See tähendab, y andmed sisaldavad veresuhkru andmedja X andmed sisaldavad kõiki funktsioone peale veresuhkru. Pärast eraldamist X ja y andmeid, saame rongi- ja katsekomplektid jagada:

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)

RandomForestRegressori koolitamine

Nüüd, kui oleme oma andmestikku skaleerinud, on aeg treenida oma algoritmi selle regressiooniprobleemi lahendamiseks, seda veidi muuta – loome mudeli, kus metsas on 20 puud ja igaüks neist 4 tasemega. Selleks saate käivitada järgmise koodi:

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)

Leiate üksikasjad kõigi parameetrite kohta RandomForestRegressor ametlikus dokumentatsioonis.

Kuna 20 puu joonistamine ja vaatamine nõuaks veidi aega ja pühendumist, saame joonistada just esimese, et näha, kuidas see erineb klassifikatsioonipuust:

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

Pange tähele, et regressioonipuul on juba igale sõlmele langevatele andmetele määratud väärtus. Need on väärtused, mis keskmistatakse 20 puu kombineerimisel. Järgides seda, mida oleme teinud klassifitseerimisega, saate joonistada ka funktsioonide tähtsuse, et näha, milliseid muutujaid regressioonimudel väärtuste arvutamisel rohkem arvesse võtab.

On aeg asuda masinõppeprobleemi lahendamisel viimase ja viimase sammu juurde ning hinnata algoritmi toimivust!

RandomForestRegressori hindamine

Regressiooniprobleemide puhul on algoritmi hindamiseks kasutatavad mõõdikud keskmine absoluutviga (MAE), keskmine ruutviga (MSE) ja keskmine ruutviga (RMSE).

1. Keskmine absoluutne viga (MAE): kui lahutame prognoositud väärtused tegelikest väärtustest, saades vead, liidame nende vigade absoluutväärtused ja saame nende keskmise. See mõõdik annab ülevaate mudeli iga ennustuse üldisest veast, mida väiksem (lähemal 0-le), seda parem.

$$
mae = (frac{1}{n})sum_{i=1}^{n}vasak | Tegelik – ennustatud õige |
$$

2. Keskmine ruudu viga (MSE): see sarnaneb MAE mõõdikuga, kuid ruudustab vigade absoluutväärtused. Samuti nagu MAE puhul, mida väiksem või lähemal 0-le, seda parem. MSE väärtus on ruudus nii, et suured vead oleksid veelgi suuremad. Üks asi, millele tähelepanu pöörata, on see, et seda on tavaliselt raske tõlgendada selle väärtuste suuruse ja asjaolu tõttu, et need ei ole andmetega samas skaalas.

$$
mse = summa_{i=1}^{D}(Tegelik – ennustatud)^2
$$

3. Root Mean Squared Error (RMSE): püüab lahendada MSE-ga tõstatatud tõlgendusprobleemi, saades selle lõplikust väärtusest ruutjuure, et skaleerida see tagasi samadele andmeühikutele. Seda on lihtsam tõlgendada ja hea, kui peame kuvama või näitama veaga andmete tegelikku väärtust. See näitab, kui palju andmed võivad erineda, nii et kui meie RMSE on 4.35, võib meie mudel teha vea, kuna see lisas tegelikule väärtusele 4.35 või vajas tegeliku väärtuse saavutamiseks 4.35. Mida lähemal 0-le, seda parem.

$$
rmse = sqrt{ summa_{i=1}^{D}(Tegelik – ennustatud)^2}
$$

Saame kasutada mis tahes neist kolmest mõõdikust võrdlema mudelid (kui meil on vaja üks valida). Samuti saame võrrelda sama regressioonimudelit erinevate argumentide väärtustega või erinevate andmetega ja seejärel arvestada hindamismõõdikutega. Seda tuntakse kui hüperparameetrite häälestamine – õppimisalgoritmi mõjutavate hüperparameetrite häälestamine ja tulemuste jälgimine.

Valides mudelite vahel, toimivad tavaliselt paremini need, millel on kõige väiksemad vead. Kui mõõdikud muutusid mudelite jälgimisel halvemaks, siis mudeli eelmine versioon oli parem või andmetes tehti olulisi muudatusi, et mudeli toimivus halvenes.

Nende väärtuste leidmiseks saate kasutada järgmist koodi:

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

Väljund peaks olema:

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

20 puu puhul on ruutkeskmine viga 1.75, mis on küll madal, kuid sellegipoolest – puude arvu suurendades ja teiste parameetritega katsetades võib see viga ilmselt veelgi väheneda.

Random Foresti kasutamise eelised

Nagu iga algoritmi puhul, on ka selle kasutamisel eelised ja puudused. Järgmises kahes osas vaatleme juhusliku metsa klassifitseerimiseks ja regressiooniks kasutamise plusse ja miinuseid.

1. Juhuslik metsaalgoritm ei ole kallutatud, kuna puud on mitu ja iga puu on treenitud juhusliku andmete alamhulga järgi. Põhimõtteliselt toetub juhuslik metsaalgoritm "rahvahulga" jõule; seetõttu väheneb algoritmi üldine nihkeaste.
2. See algoritm on väga stabiilne. Isegi kui andmekogusse lisatakse uus andmepunkt, ei mõjuta see üldist algoritmi palju, kuna uued andmed võivad mõjutada ühte puud, kuid sellel on väga raske mõjutada kõiki puid.
3. Juhusliku metsa algoritm töötab hästi, kui teil on nii kategoorilisi kui ka arvulisi tunnuseid.
4. Juhusliku metsa algoritm töötab hästi ka siis, kui andmetel puuduvad väärtused või neid pole skaleeritud.

Random Foresti kasutamise puudused

1. Juhuslike metsade peamine puudus seisneb nende keerukuses. Need nõuavad suurte ansamblite treenimisel palju rohkem arvutusressursse, kuna otsustuspuud on omavahel ühendatud suurel arvul. Kuigi – kaasaegse riistvaraga ei võta ka suure juhusliku metsa väljaõpe palju aega.

Edasiminek – käeshoitav otsast lõpuni projekt

Sinu uudishimulik loomus tekitab sinus soovi minna kaugemale? Soovitame tutvuda meiega Juhendatud projekt: "Hands-on majahinna ennustamine – masinõpe Pythonis".

Selles juhendatud projektis saate teada, kuidas luua võimsaid traditsioonilisi masinõppemudeleid ja süvaõppe mudeleid, kasutada Ensemble Learningut ja koolitada meta-õppijaid, et ennustada Scikit-Learni ja Kerase mudelite põhjal eluaseme hindu.

Kasutades Tensorflow peale ehitatud süvaõppe API-t Keras, katsetame arhitektuuridega, loome virnastatud mudelite ansambli ja koolitame meta-õppija närvivõrk (1. taseme mudel), et välja selgitada maja hinnakujundus.

Sügav õppimine on hämmastav – kuid enne selle poole pöördumist on soovitatav proovida probleemi lahendada ka lihtsamate tehnikatega, näiteks pinnapealne õppimine algoritmid. Meie algtaseme jõudlus põhineb a Juhuslik metsa regressioon algoritm. Lisaks uurime mudelite ansamblite loomist Scikit-Learni abil selliste tehnikate abil nagu kottimine ja hääletamine.

See on otsast lõpuni projekt ja nagu kõik masinõppeprojektid, alustame sellest – koos Uurimisandmete analüüs, millele järgneb Andmete eeltöötlemine ja lõpuks Madal hoone ja Süvaõppe mudelid et sobituda varem uuritud ja puhastatud andmetega.