Logistisk regresjon ved bruk av pytorch

Logistisk regresjon er en kjent maskinlæringsalgoritme som brukes til å løse binære klassifiseringsproblemer. Den er avledet fra den lineære regresjonsalgoritmen, som har en kontinuerlig utgangsvariabel, og logistisk regresjon kan til og med klassifisere mer enn to klasser ved å endre den litt. Vi vil se på konseptet logistisk regresjon og hvordan det implementeres i Pytorch, et nyttig bibliotek for å lage maskinlæring og dype læringsmodeller.

Begrepet logistisk regresjon

Logistisk regresjon er en binær klassifiseringsalgoritme. Det er en beslutningsalgoritme, som betyr at den skaper grenser mellom to klasser. Det utvider det lineære regresjonsproblemet som bruker en Aktiveringsfunksjon på utgangene for å begrense det mellom 1 og 0. Som et resultat brukes dette til binære klassifiseringsproblemer. Grafen for logistisk regresjon ser ut som figuren nedenfor:

Vi kan se at grafen er begrenset mellom 0 og 1. Normal lineær regresjon kan gi målverdien som ethvert reelt tall, men dette er ikke tilfelle med logistisk regresjon på grunn av sigmoid -funksjonen. Logistisk regresjon er basert på begrepet maksimal sannsynlighetsestimering (MLE). Maksimal sannsynlighet er ganske enkelt å ta en sannsynlighetsfordeling med et gitt sett med parametere og spørre: "Hvor sannsynlig er det at jeg ville se disse dataene hvis dataene mine ble generert fra denne sannsynlighetsfordelingen?”Det fungerer ved å beregne sannsynligheten for hvert enkelt datapunkt og deretter multiplisere alle disse sannsynlighetene sammen. I praksis legger vi til logaritmene til sannsynligheten.

Hvis vi trenger å bygge en maskinlæringsmodell, vil hvert uavhengig variabelt datapunkt være x1 * w1 + x2 * w2 ... og så videre, gi en verdi mellom 0 og 1 når den føres gjennom aktiveringsfunksjonen. Hvis vi tar 0.50 som en avgjørende faktor eller terskel. Deretter ethvert resultat større enn 0.5 blir sett på som en 1, mens ethvert resultat mindre enn det blir sett på som en 0.

I mer enn 2 klasser bruker vi en-vs-all-tilnærmingen. En-vs-all, også kjent som One-VS-REST, er en multilabel og multiklass ML-klassifiseringsprosess. Det fungerer ved å først trene en binær klassifiserer for hver kategori, og deretter montere hver klassifiserer til hver inngang for å bestemme hvilken klasse inngangen tilhører. Hvis problemet ditt har N-klasser, vil one-vs-all konvertere treningsdatasettet ditt til n binære klassifiseringsproblemer.

Tapsfunksjonen assosiert med den logistiske regresjonen er Binær kors entropi som er motsatt av informasjonsgevinst. Dette er også kjent som navnet Loggtap. Tapsfunksjonen er gitt av ligningen:

Hva er tapsfunksjon?

En tapsfunksjon er en matematisk beregning som vi ønsker å redusere. Vi ønsker å bygge en modell som nøyaktig kan forutsi hva vi ønsker, og en måte å måle modellens ytelse på er å se på tapet siden vi vet hva modellen gir ut og hva vi skal få. Vi kan trene og forbedre modellen vår ved å bruke dette tapet og justere modellens parametere deretter. Tapfunksjoner varierer avhengig av type algoritme. For lineær regresjon er gjennomsnittlig kvadratfeil og gjennomsnittlig absolutt feil populære tapsfunksjoner, mens kryssinntropi er passende for klassifiseringsproblemer.

Hva er aktiveringsfunksjonen?

Aktiveringsfunksjoner er ganske enkelt matematiske funksjoner som endrer inngangsvariabelen for å gi en ny utgang. Dette gjøres vanligvis i maskinlæring for å enten standardisere dataene eller begrense inngangen til en viss grense. Populære actionfunksjoner er sigmoid, utbedret lineær enhet (RELU), Tan (H), etc.

Hva er Pytorch?

Pytorch er et populært dypt læringsalternativ som fungerer med fakkel. Det ble opprettet av Facebooks AI -avdeling, men det kan brukes på samme måte som andre alternativer. Det brukes til å utvikle en rekke modeller, men den brukes mest i bruk av naturlige språkbehandlinger (NLP). Pytorch er alltid et flott alternativ hvis du ønsker å bygge modeller med veldig få ressurser og vil ha et brukervennlig, brukervennlig og lett bibliotek for modellene dine. Det føles også naturlig, som hjelper til med å fullføre prosessen. Vi vil bruke Pytorch for implementering av modellene våre på grunn av de nevnte årsaker. Imidlertid forblir algoritmen den samme med andre alternativer som TensorFlow.

Implementering av logistisk regresjon i Pytorch

Vi bruker trinnene nedenfor for å implementere vår modell:

1. Lag et nevralt nettverk med noen parametere som vil bli oppdatert etter hver iterasjon.
2. Itererer gjennom de gitte inndataene.
3. Inngangen vil passere gjennom nettverket ved å bruke fremover forplantning.
4. Vi beregner nå tapet ved hjelp av binær kryssinntropi.
5. For å minimere kostnadsfunksjonen, oppdaterer vi parametrene ved å bruke gradient nedstigning.
6. Gjør igjen de samme trinnene ved hjelp av oppdaterte parametere.

Vi klassifiserer Mnist datasett sifre. Dette er et populært dypt læringsproblem som er lært til nybegynnere.

La oss først importere de nødvendige bibliotekene og modulene.

Importer fakkel
fra fakkel.Autograd importvariabel
Import Torchvision.transformerer som transformering
Import Torchvision.Datasett som DSETS

Neste trinn er å importere datasettet.

tog = DSETS.Mnist (root = './data ', tog = true, transform = transforms.Heltensor (), last ned = falsk)
Test = DSETS.Mnist (root = './data ', tog = falsk, transform = transformasjon.Heltensor ())

Bruk datalaster for å gjøre dataene dine til å være iterable

Train_loader = fakkel.benyttede.data.DataLoader (DataSet = Tog, Batch_Size = Batch_Size, Shuffle = True)
test_loader = fakkel.benyttede.data.DataLoader (DataSet = Test, Batch_Size = Batch_Size, Shuffle = FALSE)

Definer modellen.

Klassemodell (fakkel.nn.Modul):
def __init __ (selv, inp, ut):
Super (modell, selv).__i det__()
selv-.lineær = fakkel.nn.Lineær (INP, ut)
def fremover (self, x):
utganger = selv.lineær (x)
Returutganger

Spesifiser hyperparametere, optimalisator og tap.

Batch = 50
N_ITERS = 1500
Epochs = n_iters / (len (tog_dataset) / batch)
INP = 784
ut = 10
alfa = 0.001
Model = LogisticRegression (INP, OUT)
Tap = fakkel.nn.Crossentropyloss ()
Optimizer = fakkel.Optimt.SGD (modell.Parametre (), LR = alfa)

Tren modellen endelig.

itr = 0
For Epoch in Range (Int (Epochs)):
for i, (bilder, etiketter) i enumerate (Train_loader):
bilder = variabel (bilder.Vis (-1, 28 * 28)))
Etiketter = variabel (etiketter)
Optimizer.null_grad ()
utganger = modell (bilder)
tapfunc = tap (utganger, etiketter)
tapfunc.bakover ()
Optimizer.steg()
itr+= 1
Hvis ITR%500 == 0:
Riktig = 0
Totalt = 0
For bilder, etiketter i test_loader:
bilder = variabel (bilder.Vis (-1, 28*28)))
utganger = modell (bilder)
_, forutsagt = fakkel.Maks (utganger.Data, 1)
Totalt+= etiketter.størrelse (0)
Riktig+= (spådd == etiketter).sum()
Nøyaktighet = 100 * Riktig/Totalt
trykk ("iterasjon er . Tap er . Nøyaktighet er ."".Format (ITR, Lossfunc.vare (), nøyaktighet)))

Konklusjon

Vi gikk gjennom forklaringen på logistisk regresjon og implementeringen av den ved hjelp av Pytorch, som er et populært bibliotek for å utvikle dype læringsmodeller. Vi implementerte MNIST -datasettklassifiseringsproblemet der vi gjenkjente sifrene basert på bildesparametrene.