Scikit Lær opplæring
Fremgangsmåte
I denne opplæringen skal vi lære om Scikit Learn Library of Python og hvordan vi kan bruke dette biblioteket til å utvikle forskjellige maskinlæringsalgoritmer. Denne guiden vil inneholde følgende innhold som vil bli diskutert en etter en med en detaljert forklaring:
- Installasjon
- Grafplotting
- Ulike datasett og deres verktøy i Scikit lærer
- Funksjonsvalg
- Trening av en maskinlæringsmodell
Trinn 01: Installasjon
Før vi kommer i gang med Scikit Learn, må vi først installere pakken fra Python -depotene. For å gjøre dette, må vi ha Python (den nyeste versjonen eller noen) lastet ned og installert på systemet vårt. For å laste ned Python på systemet ditt, naviger til lenken I.e.
“Https: // www. Python .org “. Når du er omdirigert til denne nettadressen, kan du gå til nedlastinger og klikk på Python med hvilken som helst versjon du vil laste ned som nedenfor:
Etter at Python er lastet ned, må vi nå installere den. Velg alternativet tilpasset installasjon etter å ha lagt pyton til banen.
Sjekk alle alternativene i poppevinduet for å installere pakkene med Pip med Python og fortsett og velg Neste.
Neste trinn vil være å spesifisere stedet for Python -pakkene, sjekk alle de gitte avanserte alternativene og spesifiser plasseringen og klikk på Install; Dette vil deretter starte installasjonsprosessen som vil fortsette en stund.
Nå blir Python installert på systemene våre. For å åpne Python Shell -typen, legg Python på søkemenyen og treff Enter. Python -skallet åpnes da. Nå går vi videre for å installere Scikit Learn on Python. For dette, åpne ledeteksten og skriv Python for å sjekke om pytonen kjører på systemet eller ikke. Hvis systemet returnerer versjonen av Python, betyr dette at Python kjører riktig. Da må vi sjekke versjonen av PIP for å oppgradere PIP -pakkene:
$ python
$ pip -Versjon
Etter å ha sjekket både Python- og PIP -versjonene, skriver du nå følgende kommando på ledeteksten for å installere Scikit Lær på Python.
$ pip installer scikit lære
Etter dette vil Scikit med alle pakkene begynne å installere.
Nå er Scikit Learn installert i systemet vårt, og nå kan vi bruke Scikit -pakkene til å utvikle enhver maskinlæringsalgoritme. Etter vellykket installasjon av Scikit, vil vi nå gå videre til neste trinn, hvor vi får vite hvordan vi skal plotte grafene til dataene ved hjelp av Scikit Learn.
Trinn 02: Grafplotting
Grafer er kjent som de visuelle verktøyene som hjelper til med å visualisere den gitte informasjonen hvis dataene i datasettene er for mange eller kompliserte nok til å beskrive. Grafer legger vekt på å representere forholdet mellom en eller mange variabler. For å jobbe med maskinlæringsalgoritmer, må vi kjenne til datarepresentasjonen for analyse av data for å trene og teste dataene deretter. Scikit Learn gir mange slike visualiseringspakker (i grafisk form) for de forskjellige datasettene.
Eksempel nr. 01
Visualisering av dataene i form av en graf kan fås ved hjelp av Matplotlib -pakken. Matplotlib er en Python-pakke som bidrar som basen til Sci-Kit Lær plottepakker. Scikit Learn integreres med matplotlib for plotting (visuell representasjon av dataene eller resultatene oppnådd etter trening og testing av dataene i maskinlæringsalgoritmer). La oss prøve å implementere et eksempel ved hjelp av matplotlib.
Anta at vi ønsker å plotte noen tilfeldige tall for å visualisere forholdet til hverandre. Vi kan ta disse tallene tilfeldig, e.g., 0.5, 1.5, 2.5. For å skrive koden, importerer vi Matplotlib -biblioteket fra Python -pakkene som PLT. Etter dette trinnet kan vi nå bruke PLT i stedet for å skrive matplotlib i hele koden. Deretter bruker vi denne PLT, vil vi skrive en kommando for å plotte tallene som vi allerede har valgt tilfeldig ved å bruke funksjonen “PLT. plot ("utvalgte tall") ". For å vise disse tallene på grafen i utgangen, bruker vi funksjonen “PLT. forestilling()". Koden kan opprettes på en påfølgende måte:
$ import matplotlib. Pyplot som Plt
$ plt. plot ([0.5, 1.5, 2.5])
$ plt. forestilling()
Tallene vises deretter i utgangen på grafen:
Eksempel# 02
Hvis vi ønsker å plotte dataene i form av et spredningsplott, kan vi bruke funksjonen “spredning. plott ()". Spredningsplottet representerer dataene i form av DOTS -datapunktene. Disse tomtene fungerer på to eller flere to variabler. Hver prikk eller datapunkt på grafen representerer de to forskjellige verdiene (hver på x-aksen og y-aksen) som tilsvarer et datapunkt i et datasett.
I det påfølgende eksemplet plottet vi en spredningsplott. For å gjøre det, importerer vi matplotlib pyplot som PLT. Denne PLT kan deretter brukes i stedet for matplotlib. Pyplot. Etter dette vil vi definere de to variablene x og y som x = 1, 3, 5, 7 og y = 2, 4, 6, 8. For spredningsplottet må dimensjonen til X og Y samsvares. For å plotte begge variablene, bruker vi funksjonen PLT. Spredning (“Variabel 1, variabel 2”). For å vise disse variablene på grafen, bruk funksjonen PLT. forestilling ().
$ import matplotlib. Pyplot som Plt
$ x = [1, 3, 5, 7]
$ y = [2, 4, 6, 8]
$ plt. spredning (x, y)
$ plt. forestilling ()
Forholdet mellom de to spesifiserte variablene i form av en spredt plot vil deretter vises som:
Ovennevnte eksempler kan brukes til å plotte de spesifikke dataene og til å vite om deres forhold til hverandre.
Eksempel# 03
La oss nå anta at vi jobbet med et binært datasett, og vi må klassifisere dataene som enten tilhørende klasse 0 eller klasse 1. Vi utviklet en binær klassifiserer for disse dataene ved hjelp av en maskinlæringsalgoritme, og nå vil vi vite hvor godt denne klassifisereren fungerer. For dette formålet kan vi bruke en AUC-ROC_CURVE.
I AUC -RUC -kurve forteller AUC hvilken grad klassifisereren utviklet kan forutsi klassene riktig, enten som 0 eller 1, og ROC skildrer sannsynligheten for at klassifisererne viser klassene riktig. AUC-RUC_ Curve viser kurven mellom FPR (Y-Axis) og TPR (X-Axis), som begge er ND-arrays. For å implementere denne AUC-RUC-kurven, importerer du først matplotlibpyplot som PLT slik at vi kan ringe PLT for å plotte.
Så importerer vi Numpy som NP for å lage ND-arrays. Etter denne importen fra Sklearn Metrics. Nå vil vi spesifisere x og y ved å bruke NP. Array () for å lage ND-arrays. Nd-garrays bruker numpy for å lagre sekvensielle tall i dem. For å spesifisere FPR og TPR og terskler, bruker vi metoden “Metrics.roc_curve (x, y) ”, så bruker vi disse verdiene til FPR og TPR for å lagre i ROC_AUC ved å kalle funksjonen“ Metrics.AUC () ”.
Etter at disse verdiene er spesifisert, vil vi kalle funksjonen ved å bruke “Metrics. Roccurvedisplay () ”ved å passere FPR, TPR og ROC_AUC i argumentene og lagre dem i variabel skjerm alle. Så kaller vi funksjonen. plot () og PLT. Vis () For å vise ROC-AUC-kurven med de spesifiserte parametrene i utgangen som følger:
Etter å ha kjørt den ovennevnte koden, får vi følgende utdata:
RUC-AUC-kurven er vist i utgangen nå, som representerer hvor mye vår utviklede klassifiserer har spådd klassene som 1 eller 0 riktig. ROC-AUC-kurve fungerer for datasettene med binær klassifisering.
Eksempel nr. 04
En annen grafplottmetode ved hjelp av Scikit Lær kalibreringskurven. Kalibreringskurven har et annet navn: pålitelighetsdiagrammet; Denne kurven plotter gjennomsnittet av forutsagt sannsynlighet mot den positive klassen ved Y-aksen til kurven ved å ta inngangen fra den binære klassifiseringsklassifisereren. For å implementere denne kalibreringskurven, la oss løse et eksempel der vi først vil importere datasettet "lage klassifisering" fra Sklearn Dataset Package, importere tog og test splittet fra Sklearn Model Selection, og deretter bruke Sklearn Linear Model Selection Import Logistic Regression og etter den importer kalibreringskurven og vises fra "Sklearn -kalibreringene".
Når vi har importert alle viktige og påkrevde pakker, last nå inn "Make Classification" ved hjelp vil bygge klassifiseringsmodellen ved å bruke "logisticregression ()" og passe til denne modellen på x_train og y_train.
Nå ved å bruke etikettene og sannsynlighetene som er spådd ved bruk av "klassifiserer. Forutsi sannsynlighet () ”som omgår XTEST som inngangsargument, kaller metoden“ Kalibreringskurve () “For å plotte kalibreringskurven først og deretter vise den ved å bruke“ DisplayCurve () ”.
Utgangen viser plottingen av kalibreringskurven som har brukt de sanne forutsagte sannsynlighetene fra en binær klassifiserer.
Trinn 03: Ulike datasett og deres verktøy i Scikit Lær
For å jobbe med maskinlæringsalgoritmer, må vi ha datasettene som vi kan bruke til å bygge de spesifikke algoritmene på og oppnå de ønskede utgangene. Scikit Learn kommer med noen pakker som har standard innebygde datasett lagret i det med navnet Sklearn. datasett. For å jobbe med datasettene, kan vi enten lese dem ved hjelp av Sklearn standard datasett depoter eller ved å generere dem.
Datasettene som Sklearn gir brukeren, er noen relativt små leketøysdatasett og andre datasett i den virkelige verden som er enorme og har informasjon relatert til verdslige applikasjoner. Standardstørrelse og små datasett kan oppnås ved hjelp av datasettlastere, mens de virkelige datasettene lastes gjennom datasett-henter.
I dette eksemplet vil vi først importere leketøysdatasettene fra “Sklearn. datasett ”. For å importere datasettet, bruker vi Sklearn.datasett. Sklearn.Datasett tillater import av datasettene fra standarddatasettene. Ulike datasett kan lastes fra Sklearn.Datasett ved hjelp av denne kommandoen.
$ fra Sklearn. Datasett importerer Load_Digits
Her har vi importert sifrenees datasett fra Sklearn.datasett. Vi kan laste inn hvilket som helst annet datasett ved å bruke den samme kommandoen med den enkle modifiseringen; Det vil si at vi må erstatte “Load_digits” med navnet på det spesifikke datasettet som vi ønsker å laste inn i ovennevnte kommando. Nå i neste trinn vil vi laste inn datasettet ved å bruke metoden “Data Set_name ()” og deretter lagre det i hvilken som helst variabel, la oss si datasett, som vi har gjort i denne kommandoen
$ Dataset = LOAD_DIGITS ().
Inntil dette trinnet har datasettet blitt lastet ned i sifrene. For å vise dataene i dette datasettet, bruker vi utskriftsfunksjonen og vil passere variabelnavnet.Data i argumentene til utskriftsfunksjonen.
$ print (datasett.data)
Nå kjører vi alle over eksplisitt nevnte kommandoer i form av en kode, og den vil gi utdataene som:
Etter å ha utført koden, fikk vi en utdata som viser alle dataene som er lagret i datasettet med belastning _digits.
Hvis vi vil vite om spesifikasjonen av datasettet når det hvert datasett.
For å få denne informasjonen, kan vi ganske enkelt bruke funksjonen “DataSet_Varaiable Name. form". For å implementere dette, importer datasettet (LOAD_IRIS) fra Sklearn.Datasett og last deretter dette datasettet ved å kalle metoden “Load_iris ()” og lagre det i “Iris. laste". Skriv deretter ut spesifikasjonen av datasettet ved hjelp av utskriften (Loadiris.form) på følgende måte:
Ovennevnte kode vil ha følgende utgang etter utførelse:
Utgangen har returnert verdiene (150, 4). Dette betyr at datasettet har 150 prøveeksempler og 4 attributter som vi kan bruke til å lage vår maskinlæringsalgoritme i henhold til etterspørselen.
I neste eksempel lærer vi nå hvordan du importerer datasett i den virkelige verden og jobber med dem. For data fra den virkelige verden henter vi filene ved hjelp av hentingsfunksjonen som laster ned og trekker ut datasettet fra det spesifikke nettstedets cache/arkiv og laster det i Sklearn. datasett.
La oss ta data fra den virkelige verden fra de virkelige datasettene ved hjelp av Sklearn.datasett og jobbe med det. Her vil vi ta dataene fra noen nyhetsgrupper, "TV -nyhetsgrupper nettsteder". Nå vil vi importere datasettet for dette spesifikke nettstedet ved først å hente filene fra nettstedets depot. Så laster vi treningsdataene fra de hentet filene til disse dataene til Sklearn.datasett som kaller lastemetoden, i.e., “DataSet_name (Subset =” enten test eller togdata som skal legges inn ”)” og vil deretter lagre dem i en eller annen variabel “NewspaperDataload”.
Etter dette vil vi ganske enkelt vise datasettets målnavn. "Målnavn" er filene som inneholder de virkelige datafilene til datasettene. La oss ringe utskriftsfunksjonen for å vise navnene på filene som er til stede i datasettet ved å skrive kommandoene:
$ pprint (liste (“DataSetName. Target ”_Names)))
Vi har importert pprint her fordi målnavnet inneholder listen over filen, og vi vil at denne listen skal vises som den er. For å vise denne listen har vi importert PPRint -pakken først, og deretter bruker den, har vi vist listen over filnavnene i datasettet som vi allerede har lastet inn "Sklearn.datasett ”ved å hente filene fra nettstedet. Vi har implementert den ovennevnte koden i Python, og dens produksjon ble ut for å være slik:
Nå er listen over datasettene blitt vist av systemet. Hvis vi vil vite attributtene til dette datasettet, e.g., Antall eksempeleksempler datasettet inneholder, det totale antallet funksjoner i datasettet osv. Vi kan ganske enkelt bruke utskriften (datasettnavn. filnavn. form) siden vi allerede har forklart at all informasjon om datasettet er lagret i filen File_name eller Target_name, og den vil returnere attributtinformasjonen til datasettet som den er.
$ print (avis dataload. filnavn. form)
Trinn 04: Funksjonsvalg
I maskinlæringsalgoritmer er det viktigste aspektet som kontrollerer utgangen fra algoritmen funksjonene. Funksjoner bidrar i stor grad til å bygge enhver maskinlæringsalgoritme. All behandlingen gjøres på datasettene som er basert på funksjonene. Funksjoner kan gjøre algoritmene robuste eller en fullstendig feil når det gjelder nøyaktighet (beste prediksjon eller estimering) for beslutningsgrensen. Hvis det eksisterer overflødige funksjoner eller et større antall funksjoner som kreves, bidrar dette til å overmontere i utgangen.
Overmontering er fenomenet der en modell som er opplært på datasett som har flere funksjoner enn nødvendig og har en treningsfeil nærmest null, men når den er opplært på testdatasettet, fungerer ikke modellen bra på det testdatasettet og klarer derfor ikke å ta de riktige beslutningene. For å unngå sjansene for at den trente modellen blir overfittet, slipper vi noen av de unødvendige funksjonene. Denne dimensjonalitetsreduksjonen kan gjøres på flere måter ved å bruke Scikit -læringen.
Eksempel nr. 01
Den første metoden for å fjerne funksjonen er gjennom en terskel med lav varians; I denne typen funksjonsvalg fjerner vi disse funksjonene fra datasettene som har lav varians som er under de gitte terskler. Funksjoner med lav varians er de som bidrar med samme verdi gjennom datasettet.
La oss prøve et eksempel på funksjonsreduksjon. Anta at vi har et datasett som har tre funksjoner i binære data. I vårt eksempel har sifferedatasettene fire kolonner som sine fire funksjoner. Hvis vi ønsker å fjerne en funksjon med alle eksempler på eksempler fra datasettet, vil vi bruke variansformelen og bygge en variansterskel på det. Hvis noen funksjon har lav varians, blir terskelen deretter fjernet fra datasettet.
Vi importerer først variansterskelen fra "Sklearn Feature_Selection". Når variansterskelen er importert, vil vi deretter sette verdien av denne terskelen som i vårt tilfelle har definert som “0.5 ”. Så alle funksjonskolonner som har en verdi som er mindre enn denne terskelen, vil droppe ut av dette sifferdatasettet.
For å gjøre det, vil vi kalle metoden “Variansterskel ()”. I funksjonens argumenter vil vi passere terskelverdien til å være 0.5 og lagre den i en eller annen variabel "terskel". Etter dette vil vi kalle funksjonen “terskelholder. fit_transform () ”og send datasettet til denne funksjonen og la det lagre det med navnet new_dataset. Når vi er ferdige med disse trinnene, skriver vi ut datasettet som vist:
Som det kan sees i utdataene at før vi brukte variansterskelen på datasettet, hadde den 4 funksjoner, og nå etter anvendelsen av variansterskelen på datasettet, instruerte vi systemet om å fjerne alle kolonnene som hadde varians under den terskelverdi, i.e., 0.5 viser utdata tre kolonner i datasettet, noe som betyr at den ene kolonnen ble beregnet for å ha varians mindre enn terskelen, så den ble droppet ut av datasettet for å unngå redundans i datasettet og for å gjøre modellen trent på dataene satt til å være mer presis når det gjelder nøyaktighet og unngå overmasse.
Eksempel #02
Den andre metoden for å velge funksjonene i datasettet er gitt av “Select K-Best” -metoden. For implementering av denne metoden vil IRIS -datasettet bli importert fra "SklearNdatasets", og så laster vi dette datasettet og lagrer det i en tilfeldig variabel som Iris. For å laste inn datasettet, vil vi kalle “loadDataset_name ()”.
CHI2 måler forskjellen mellom forventede og observerte funksjoner og brukes til klassifiseringsoppgaver. Etter å ha lastet inn datasettet til iris og importert Select K Best og CHI2, vil vi nå bruke dem i “Fit. Transform () -funksjon ”. SelectKbest (chi2, k = 2). passe.transform (), det passer først til dataene som tar treningsdataene som inndata og transformerer dem deretter. Deretter synker K i SelectKbest -metoden kolonnene og velger de funksjonene som har scoret den høyeste i funksjoner. I vårt tilfelle vil vi velge de to funksjonene når vi velger K -verdien lik 2.
I dette eksemplet, når vi ganske enkelt lastet inn datasettet og deretter viste det, var det fire kolonner som funksjoner i datasettet, men nå etter at vi har brukt SelectKBest -metoden med K = 2 på datasettet nå, kom det nye datasettet ut med å ha To kolonner som funksjoner dette betyr at SelectKbest har valgt de to beste funksjonene fra det originale datasettet.
Eksempel #03
En annen måte å velge den viktige funksjonen fra datasettet er gitt av SCIKIT Lær ved å bruke "Recursive Feature Elimination (RFE)". RFE slipper de mindre viktige funksjonene fra datasettet ved å gjøre rekursiv trening av datasettet. RFE velger funksjonsnummeret for seg selv ved å bruke medianen til det totale antallet funksjoner i datasettet, og det slipper bare en funksjon fra datasettet ved hver iterasjon. For å implementere RFE, importer først bibliotekene som er pålagt å bygge koden gjennom disse kommandoene.
Nå har vi importert pakkene for RFE fra Sklearn. trekk. utvalg. For å lage datasettet har vi lastet inn "make_regression ()" -funksjonen, og i dens argumenter har vi passert de parametrene vi ønsker i datasettet.
$ X, y = make_regression (n_samples = 10000, n_features = 100, n_informative = 2)
$ print (x.form)
Så skriver vi ut dette datasettet for å vite om den nøyaktige formen eller attributtene til datasettet. Etter å ha vist datasettet, vil vi nå bruke den rekursive funksjonen eliminator. For dette formålet vil vi lage en modell som beslutningstegressor (). Etter at modellen er fullført nå ved hjelp av RFECV () som vi importerte tidligere, vil vi passere verbose, modell/estimator, trinn, scoring og CV som parametrene som kreves i argumentene til RFECV.
Nå for å fjerne den rekursive funksjonen, vil vi passe og transformere dataene. Hele den forklarte prosedyren kan skrives som koden nedenfor:
Nå vil funksjonene rekursivt falt i henhold til vårt krav etter hver iterasjon, som det kan vises tydelig i utdataene. Denne rekursive funksjonen eliminering vil bli videreført til vi når det punktet hvor vi sitter igjen med to viktige funksjoner av de totalt 100 funksjonene som er til stede i det originale datasettet.
Eksempel nr. 04
En annen metode som vi kan bruke for å fjerne de ekstra funksjonene, eller vi kan ganske enkelt slippe dem på grunn av deres redundans, er "SelectFrom -modellen" sammen med "lineære modellene". Når avhandlingene lineære modellene på en eller annen måte blir straffet med L1 -normen, eksisterer løsningen deres tynt siden de fleste av koeffisientene deres blir lik null.
I dimensjonalitetsreduksjon eller funksjonsvalg hjelper disse lineære modellene, sammen med SelectFrom-modellen, til å velge den ikke-null-sameffektive. De fungerer mest for regresjonsproblemet. For å implementere SelectFrom -modellen, må vi først importere LinearSVC fra Sklearn.SVM, LinearSVC er den lineære støttevektorklassifisereren som finner den beste passformlinjen (hyperplan) for å dele og klassifisere dataene i forskjellige kategorier; Når vi har fått hyperplanet i LSVC, kan vi deretter gi hvilken som helst funksjon til denne best fit -modellen for å vite hvilken klasse den funksjonen som vil tilhøre, så vil vi importere datasettet fra Sklearn. ATA -sett, og etter dette må vi importere “SelectFrom -modellen” fra Sklearn.Funksjonsvalg.
Etter at de nødvendige pakkene er importert, laster vi IRIS -datasettet ved hjelp av LOAD_DATASET () og viser deretter attributtene til IRIS -datasettet når det gjelder eksempler på eksempler og antall funksjoner den har ved å bruke " .form ”-metode. Etter å ha kjent formen på datasettet, vil vi nå bruke “LinearSVC ().FIT (_Loaded Data Set) ”-modell med C = 0.01, en straff for LinearSVC = L1 som inngangsargument. Bygg deretter modellen med "SelectFrom Model ()" og transformer deretter modellen ved å bruke "Model.forvandle()". Vis nå det nye transformasjonsdatasettet og vis dets attributt ved hjelp av dataene “set_new.form".
Formen på datasettet før du brukte "SelectFrom -modellen" for funksjonsvalget var (150, 4), noe som betyr at det hadde 150 prøveeksempler og fire attributter, men når vi først brukte funksjonsvalget på datasettet ved å bruke "LinearSVC ”Og SELECTFROM MODEL.
Trinn 05: Forbehandling av data
Datasettene som vi jobber med for å utvikle og trene forskjellige maskinlæringsalgoritmer på dem, er ikke alltid de som er i sin perfekte form som skal brukes til å bygge modellen. Vi må endre disse datasettene i henhold til våre krav. Det aller første trinnet vi trenger å gjøre etter å ha lastet datasettet, og før trening er modellen dataforbehandling. Ved forbehandling av data mener vi:
- Funksjonsskalering
- Funksjonsnormalisering / standardisering
Funksjonsskalering
Den viktigste oppgaven med dataforbehandling er funksjonsskalering. Funksjonsskalering gjøres for å lage alle funksjonene i datasettet har samme enhet; Ellers vil ikke algoritmen trene ordentlig, og det kan påvirke ytelsen til algoritmen ved å bremse prosessen. Skalering kan gjøres ved hjelp av MinMaxScaler eller Maxabsscaler. Funksjonsskalering Angir funksjonen verdier mellom null og en for det meste, og noen ganger på forespørsel, kan den begrense verdien av en funksjon til enhetsstørrelsen.
Her vil vi implementere et eksempel der vi først skal importere forbehandling fra Sklearn, og så vil vi importere Numpy. Numpy brukes i funksjonene der vi trenger å jobbe med matriser. Nå lager vi en ND-array ved hjelp av Numpy. For å gjøre funksjonsskalering på denne matrisen som vi har laget, vil vi først bruke metoden “forbehandling. MinMaxScaler () ”. Etter dette trinnet bruker vi MinMaxScaler på matrisen ved å kalle metoden “MinMaxScaler. fit_transform () ”og vil gi denne matrisen i argumentene. Koden kan skrives på nytt som:
Utgangen etter at funksjonsskalering er utført på “x” gir verdien av en matrise mellom null og en. Maxabsscaler fungerer stort sett det samme som MinMaxScaler, men denne skaleren skalerer datamavstandene mellom negativ en (-1) og positiv en (+1). Koden for Maxabsscaler er gitt av:
I utgangen er verdiene til data “x” blitt returnert i kontinuerlig form fra området som varierer mellom -1 til +1.
Funksjonsnormalisering / standardisering
Vi lærer om dataforbehandlingsteknikker i dette eksemplet i dette eksemplet. La oss først importere fra Sklearn -forbehandling og etter å ha importert forbehandlingen fra Sklearn, og importerer også Numpy siden vi nå skal jobbe med ND -matriser. Lag nå en ND-array og lagre den i “X”. Nå må vi utføre den gjennomsnittlige normaliseringen/standardiseringen på disse dataene. For å gjøre dette, vil vi bruke den konvensjonelle metoden “forbehandling. Standardscaler. passform ("Skriv inn dataene som skal normaliseres") "her") ". Verdien fra funksjonen vil da bli lagret i en variabel, e.g., Skalere. Utfør nå standardiseringen på de gitte data x med metode, e.g. “Skalere. Transform (“Data”) ”og vise de nylig transformerte dataene da:
Dataene “x” er standardisert med middelverdien nærmest null. Normalisering/standardisering av dataene gjøres for å unngå overflødige eller duplikater i datasettet. Gjennomsnittlig normalisering/ standardisering sikrer bare de relaterte dataene i datasettene. Dessuten tar den også tak i eventuelle problemer forårsaket på grunn av modifikasjoner, e.g., Sletting av data, tillegg av nye data eller hvilken som helst oppdatering i datasettene som kan bli et hinder i fremtiden.
Nå som vi har lært mest om Scikit Learn -pakker som vi kan bruke til å bygge maskinlæringsalgoritmer. Vi bør teste våre evner med Scikit Lær en funksjon som vi har brukt ovenfor i denne guiden og utvikle en maskinlæringsalgoritme for først å trene en modell på det spesifikke datasettet og deretter teste den modellen ved å kjøre den på det ukjente testdatasettet til til Få en praktisk opplevelse på denne scikit-læringsfunksjonene/pakkene. La oss sparke av implementeringen av Scikit Learn -funksjonene for maskinlæringsalgoritmen eller modellen.
Trinn 06: Modelltrening ved hjelp av SCIKIT Lær
Vi vil trene "lineær regresjonsmodell" på husprisdatasettet som vi vil opprette oss selv i koden senere. Lineær regresjon finner den beste linjen som passer for datapunktene som er gitt i datasettet. Denne linjen er plottet på datapunktene på grafen. Vi bruker denne linjen og deretter for å forutsi verdiene som vår togmodell vil forutsi når den vil bli testet på noen testdata med troen på at utdatapunkter generert etter å ha kjørt testdataene på modellen vil følge linjen som de opprinnelige dataene eller treningen Data har fulgt.
For å jobbe med den lineære regresjonsmodellen, må vi importere matplotlib -biblioteket, deretter fra scikit lære, vil vi importere den lineære modellen, matriser og ethvert modellvalg for å trene modellen senere i koden. For å opprette datasettet med husprisen, vil vi importere NP fra Numpy og opprette den to ND-array med navn “Areasq_footage_x” og “HousePrice_y,”.
Etter å ha opprettet disse to nd-arrays, vil vi plotte verdiene deres på plottet ved å bruke “spredning.plot () ”ved å merke x-aksen til grafen som 'området til huset' og y-aksen som 'prisen på huset'. Når datapunktene er plottet, vil vi deretter trene modellen ved å bruke "LinearRegression () -modellen". Vi vil deretter utvide dimensjonene til ND-array "områdeneq_footage_x", og så blir den lagret i den nye variabelen "X_New". Så bruker vi “Model_house.FIT () ”og vil passere“ X_New ”og“ HousePrice_y ”i sine innspillsargumenter for å passe modellen for den beste linjen.
Vi vil lage hypotesen om den beste linjen som passer med "y = theta0* x + theta1" og vil plotte disse forventede utgangene til de virkelige gitte dataene og plotte grafen. Denne grafen vil gi oss beskjed om den beste passformen for de gitte datapunktene, basert på hvilken vi vil forutsi utdataene fra datapunktene for testdata forutsagt som riktige eller ikke.
Dette er grafen vi oppnådde før vi trener modellen. Alle datapunktene her er plottet etter verdiene til både x-aksen og y-aksen.
Denne grafen er utdataene fra den trente modellen, og den viser den beste passformen for å forutsi utdataene for datapunktene hvis den trente modellen blir evaluert på noen testdata.
Konklusjon
Scikit Learn er et bibliotek for Python som bruker Sklearn -pakken for å jobbe med sine forskjellige tilgjengelige funksjoner for å bygge enhver maskinlæringsalgoritme. I denne opplæringen har vi lært at Scikit lærer av veldig grunnleggende trinn (installasjon av Scikit Learn on Python til den komplekse opplæringen en modell ved hjelp av scikit lære pakker). I mellom fra det grunnleggende til det komplekse nivået har vi diskutert grafplotting, lasting av datasett, funksjonsvalg og dataforbehandling av data. Vi håper du vil finne denne opplæringen nyttig i å utvikle kunnskapen din om SCI-Kit Learn.