22 KiB

Raw Permalink Blame History

Logistisk regresjon for å forutsi kategorier

Quiz før forelesning

Denne leksjonen er tilgjengelig i R!

Introduksjon

I denne siste leksjonen om regresjon, en av de grunnleggende klassiske ML-teknikkene, skal vi se nærmere på logistisk regresjon. Du kan bruke denne teknikken til å oppdage mønstre for å forutsi binære kategorier. Er dette godteri sjokolade eller ikke? Er denne sykdommen smittsom eller ikke? Vil denne kunden velge dette produktet eller ikke?

I denne leksjonen vil du lære:

Et nytt bibliotek for datavisualisering
Teknikker for logistisk regresjon

✅ Fordyp deg i å arbeide med denne typen regresjon i dette Learn-modulet

Forutsetning

Etter å ha jobbet med gresskar-dataene, er vi nå kjent nok med dem til å innse at det finnes én binær kategori vi kan jobbe med: Color.

La oss bygge en logistisk regresjonsmodell for å forutsi, gitt noen variabler, hvilken farge et gitt gresskar sannsynligvis har (oransje 🎃 eller hvit 👻).

Hvorfor snakker vi om binær klassifisering i en leksjon om regresjon? Bare av språklig bekvemmelighet, siden logistisk regresjon egentlig er en klassifiseringsmetode, om enn en lineær-basert en. Lær om andre måter å klassifisere data på i neste leksjonsgruppe.

Definer spørsmålet

For vårt formål vil vi uttrykke dette som en binær: 'Hvit' eller 'Ikke hvit'. Det finnes også en 'stripet' kategori i datasettet vårt, men det er få forekomster av den, så vi vil ikke bruke den. Den forsvinner uansett når vi fjerner nullverdier fra datasettet.

🎃 Fun fact: Vi kaller noen ganger hvite gresskar for 'spøkelsesgresskar'. De er ikke veldig lette å skjære ut, så de er ikke like populære som de oransje, men de ser kule ut! Så vi kunne også formulert spørsmålet vårt som: 'Spøkelse' eller 'Ikke spøkelse'. 👻

Om logistisk regresjon

Logistisk regresjon skiller seg fra lineær regresjon, som du lærte om tidligere, på noen viktige måter.

🎥 Klikk på bildet ovenfor for en kort videooversikt over logistisk regresjon.

Binær klassifisering

Logistisk regresjon tilbyr ikke de samme funksjonene som lineær regresjon. Den førstnevnte gir en prediksjon om en binær kategori ("hvit eller ikke hvit"), mens den sistnevnte er i stand til å forutsi kontinuerlige verdier, for eksempel gitt opprinnelsen til et gresskar og tidspunktet for innhøstingen, hvor mye prisen vil stige.

Infografikk av Dasani Madipalli

Andre klassifiseringer

Det finnes andre typer logistisk regresjon, inkludert multinomial og ordinal:

Multinomial, som innebærer å ha mer enn én kategori - "Oransje, Hvit og Stripet".
Ordinal, som innebærer ordnede kategorier, nyttig hvis vi ønsket å ordne resultatene våre logisk, som våre gresskar som er ordnet etter et begrenset antall størrelser (mini, sm, med, lg, xl, xxl).

Variabler trenger IKKE å korrelere

Husker du hvordan lineær regresjon fungerte bedre med mer korrelerte variabler? Logistisk regresjon er det motsatte - variablene trenger ikke å samsvare. Dette fungerer for disse dataene som har noe svake korrelasjoner.

Du trenger mye rene data

Logistisk regresjon gir mer nøyaktige resultater hvis du bruker mer data; vårt lille datasett er ikke optimalt for denne oppgaven, så husk det.

🎥 Klikk på bildet ovenfor for en kort videooversikt over forberedelse av data for lineær regresjon

✅ Tenk på hvilke typer data som egner seg godt for logistisk regresjon

Øvelse - rydd opp i dataene

Først, rydd opp i dataene litt, fjern nullverdier og velg bare noen av kolonnene:

Legg til følgende kode:


columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
pumpkins = full_pumpkins.loc[:, columns_to_select]

pumpkins.dropna(inplace=True)

Du kan alltid ta en titt på din nye dataframe:

pumpkins.info

Visualisering - kategorisk plott

Nå har du lastet opp startnotatboken med gresskar-data igjen og ryddet den slik at du har et datasett som inneholder noen få variabler, inkludert Color. La oss visualisere dataene i notatboken ved hjelp av et annet bibliotek: Seaborn, som er bygget på Matplotlib som vi brukte tidligere.

Seaborn tilbyr noen smarte måter å visualisere dataene dine på. For eksempel kan du sammenligne distribusjoner av dataene for hver Variety og Color i et kategorisk plott.

Lag et slikt plott ved å bruke funksjonen catplot, med gresskar-dataene pumpkins, og spesifisere en fargekartlegging for hver gresskarkategori (oransje eller hvit):
```
import seaborn as sns

palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}

sns.catplot(
data=pumpkins, y="Variety", hue="Color", kind="count",
palette=palette, 
)
```
Ved å observere dataene kan du se hvordan Color-dataene relaterer seg til Variety.

✅ Gitt dette kategoriske plottet, hvilke interessante utforskninger kan du forestille deg?

Datapreprosessering: funksjons- og etikettkoding

Datasettet vårt inneholder strengverdier for alle kolonnene. Å jobbe med kategoriske data er intuitivt for mennesker, men ikke for maskiner. Maskinlæringsalgoritmer fungerer godt med tall. Derfor er koding et veldig viktig steg i datapreprosesseringen, siden det lar oss gjøre kategoriske data om til numeriske data, uten å miste informasjon. God koding fører til å bygge en god modell.

For funksjonskoding finnes det to hovedtyper av kodere:

Ordinal koder: passer godt for ordinale variabler, som er kategoriske variabler der dataene følger en logisk rekkefølge, som kolonnen Item Size i datasettet vårt. Den lager en kartlegging slik at hver kategori representeres av et tall, som er rekkefølgen til kategorien i kolonnen.
```
from sklearn.preprocessing import OrdinalEncoder

item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
ordinal_features = ['Item Size']
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
```
Kategorisk koder: passer godt for nominelle variabler, som er kategoriske variabler der dataene ikke følger en logisk rekkefølge, som alle funksjonene bortsett fra Item Size i datasettet vårt. Det er en one-hot encoding, som betyr at hver kategori representeres av en binær kolonne: den kodede variabelen er lik 1 hvis gresskaret tilhører den Variety og 0 ellers.
```
from sklearn.preprocessing import OneHotEncoder

categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
categorical_encoder = OneHotEncoder(sparse_output=False)
```

Deretter brukes ColumnTransformer til å kombinere flere kodere i ett enkelt steg og anvende dem på de riktige kolonnene.

    from sklearn.compose import ColumnTransformer
    
    ct = ColumnTransformer(transformers=[
        ('ord', ordinal_encoder, ordinal_features),
        ('cat', categorical_encoder, categorical_features)
        ])
    
    ct.set_output(transform='pandas')
    encoded_features = ct.fit_transform(pumpkins)

For å kode etiketten bruker vi scikit-learn-klassen LabelEncoder, som er en hjelpeklasse for å normalisere etiketter slik at de bare inneholder verdier mellom 0 og n_classes-1 (her, 0 og 1).

    from sklearn.preprocessing import LabelEncoder

    label_encoder = LabelEncoder()
    encoded_label = label_encoder.fit_transform(pumpkins['Color'])

Når vi har kodet funksjonene og etiketten, kan vi slå dem sammen til en ny dataframe encoded_pumpkins.

    encoded_pumpkins = encoded_features.assign(Color=encoded_label)

✅ Hva er fordelene med å bruke en ordinal koder for kolonnen Item Size?

Analyser forholdet mellom variabler

Nå som vi har forhåndsprosesserte dataene, kan vi analysere forholdet mellom funksjonene og etiketten for å få en idé om hvor godt modellen vil kunne forutsi etiketten gitt funksjonene. Den beste måten å utføre denne typen analyse på er å plotte dataene. Vi bruker igjen Seaborn-funksjonen catplot for å visualisere forholdet mellom Item Size, Variety og Color i et kategorisk plott. For å bedre plotte dataene bruker vi den kodede kolonnen Item Size og den ukodede kolonnen Variety.

    palette = {
    'ORANGE': 'orange',
    'WHITE': 'wheat',
    }
    pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']

    g = sns.catplot(
        data=pumpkins,
        x="Item Size", y="Color", row='Variety',
        kind="box", orient="h",
        sharex=False, margin_titles=True,
        height=1.8, aspect=4, palette=palette,
    )
    g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
    g.set_titles(row_template="{row_name}")

Bruk et swarm-plott

Siden Color er en binær kategori (Hvit eller Ikke), trenger den 'en spesialisert tilnærming til visualisering'. Det finnes andre måter å visualisere forholdet mellom denne kategorien og andre variabler.

Du kan visualisere variabler side om side med Seaborn-plott.

Prøv et 'swarm'-plott for å vise distribusjonen av verdier:

palette = {
0: 'orange',
1: 'wheat'
}
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)

Vær oppmerksom: koden ovenfor kan generere en advarsel, siden Seaborn har problemer med å representere så mange datapunkter i et swarm-plott. En mulig løsning er å redusere størrelsen på markøren ved å bruke parameteren 'size'. Vær imidlertid oppmerksom på at dette påvirker lesbarheten til plottet.

🧮 Vis meg matematikken

Logistisk regresjon baserer seg på konseptet 'maksimal sannsynlighet' ved bruk av sigmoid-funksjoner. En 'Sigmoid-funksjon' på et plott ser ut som en 'S'-form. Den tar en verdi og kartlegger den til et sted mellom 0 og 1. Kurven kalles også en 'logistisk kurve'. Formelen ser slik ut:

der sigmoids midtpunkt befinner seg ved x's 0-punkt, L er kurvens maksimumsverdi, og k er kurvens bratthet. Hvis resultatet av funksjonen er mer enn 0.5, vil etiketten i spørsmålet bli gitt klassen '1' av det binære valget. Hvis ikke, vil den bli klassifisert som '0'.

Bygg modellen din

Å bygge en modell for å finne disse binære klassifiseringene er overraskende enkelt i Scikit-learn.

🎥 Klikk på bildet ovenfor for en kort videooversikt over å bygge en lineær regresjonsmodell

Velg variablene du vil bruke i klassifiseringsmodellen din og del opp trenings- og testsett ved å kalle train_test_split():

from sklearn.model_selection import train_test_split

X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
y = encoded_pumpkins['Color']

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

Nå kan du trene modellen din ved å kalle fit() med treningsdataene dine, og skrive ut resultatet:

from sklearn.metrics import f1_score, classification_report 
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('F1-score: ', f1_score(y_test, predictions))

Ta en titt på modellens resultattavle. Det er ikke dårlig, med tanke på at du bare har rundt 1000 rader med data:

                   precision    recall  f1-score   support

                0       0.94      0.98      0.96       166
                1       0.85      0.67      0.75        33

    accuracy                                0.92       199
    macro avg           0.89      0.82      0.85       199
    weighted avg        0.92      0.92      0.92       199

    Predicted labels:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
    0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
    0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
    0 0 0 1 0 0 0 0 0 0 0 0 1 1]
    F1-score:  0.7457627118644068

Bedre forståelse via en forvirringsmatrise

Mens du kan få en resultattavlerapport termer ved å skrive ut elementene ovenfor, kan du kanskje forstå modellen din bedre ved å bruke en forvirringsmatrise for å hjelpe oss med å forstå hvordan modellen presterer.

🎓 En 'forvirringsmatrise' (eller 'feilmatrise') er en tabell som uttrykker modellens sanne vs. falske positive og negative, og dermed måler nøyaktigheten av prediksjonene.

For å bruke en forvirringsmatrise, kall confusion_matrix():

from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)

Ta en titt på modellens forvirringsmatrise:

array([[162,   4],
       [ 11,  22]])

I Scikit-learn er rader (akse 0) faktiske etiketter og kolonner (akse 1) predikerte etiketter.

	0	1
0	TN	FP
1	FN	TP

Hva skjer her? La oss si at modellen vår blir bedt om å klassifisere gresskar mellom to binære kategorier, kategori 'hvit' og kategori 'ikke-hvit'.

Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en sann negativ, vist av det øverste venstre tallet.
Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en falsk negativ, vist av det nederste venstre tallet.
Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en falsk positiv, vist av det øverste høyre tallet.
Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en sann positiv, vist av det nederste høyre tallet.

Som du kanskje har gjettet, er det å foretrekke å ha et større antall sanne positive og sanne negative og et lavere antall falske positive og falske negative, noe som innebærer at modellen presterer bedre. Hvordan henger forvirringsmatrisen sammen med presisjon og tilbakekalling? Husk, klassifiseringsrapporten som ble skrevet ut ovenfor viste presisjon (0.85) og tilbakekalling (0.67).

Presisjon = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461

Tilbakekalling = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666

✅ Spørsmål: Ifølge forvirringsmatrisen, hvordan gjorde modellen det? Svar: Ikke dårlig; det er et godt antall sanne negative, men også noen få falske negative.

La oss gå tilbake til begrepene vi så tidligere ved hjelp av forvirringsmatrisens kartlegging av TP/TN og FP/FN:

🎓 Presisjon: TP/(TP + FP) Andelen relevante instanser blant de hentede instansene (f.eks. hvilke etiketter som ble godt merket)

🎓 Tilbakekalling: TP/(TP + FN) Andelen relevante instanser som ble hentet, enten de var godt merket eller ikke

🎓 f1-score: (2 * presisjon * tilbakekalling)/(presisjon + tilbakekalling) Et vektet gjennomsnitt av presisjon og tilbakekalling, der det beste er 1 og det verste er 0

🎓 Støtte: Antall forekomster av hver etikett som ble hentet

🎓 Nøyaktighet: (TP + TN)/(TP + TN + FP + FN) Prosentandelen av etiketter som ble korrekt forutsagt for et utvalg.

🎓 Makro Gjennomsnitt: Beregningen av det uvektede gjennomsnittet av metrikker for hver etikett, uten å ta hensyn til ubalanse i etiketter.

🎓 Vektet Gjennomsnitt: Beregningen av gjennomsnittet av metrikker for hver etikett, som tar hensyn til ubalanse i etiketter ved å vekte dem etter deres støtte (antall sanne instanser for hver etikett).

✅ Kan du tenke deg hvilken metrikk du bør følge med på hvis du vil at modellen din skal redusere antall falske negative?

Visualiser ROC-kurven for denne modellen

🎥 Klikk på bildet ovenfor for en kort videooversikt over ROC-kurver

La oss gjøre én visualisering til for å se den såkalte 'ROC'-kurven:

from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])

fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()

Ved hjelp av Matplotlib, plott modellens Receiving Operating Characteristic eller ROC. ROC-kurver brukes ofte for å få en oversikt over utdataene fra en klassifiserer i form av sanne vs. falske positive. "ROC-kurver har vanligvis sanne positive på Y-aksen, og falske positive på X-aksen." Dermed er brattheten på kurven og avstanden mellom midtlinjen og kurven viktig: du vil ha en kurve som raskt går opp og over linjen. I vårt tilfelle er det falske positive i starten, og deretter går linjen opp og over riktig:

Til slutt, bruk Scikit-learns roc_auc_score API for å beregne den faktiske 'Area Under the Curve' (AUC):

auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)

Resultatet er 0.9749908725812341. Siden AUC varierer fra 0 til 1, ønsker du en høy score, ettersom en modell som er 100 % korrekt i sine prediksjoner vil ha en AUC på 1; i dette tilfellet er modellen ganske god.

I fremtidige leksjoner om klassifiseringer vil du lære hvordan du kan iterere for å forbedre modellens resultater. Men for nå, gratulerer! Du har fullført disse regresjonsleksjonene!

🚀Utfordring

Det er mye mer å utforske når det gjelder logistisk regresjon! Men den beste måten å lære på er å eksperimentere. Finn et datasett som egner seg til denne typen analyse og bygg en modell med det. Hva lærer du? tips: prøv Kaggle for interessante datasett.

Quiz etter forelesning

Gjennomgang & Selvstudium

Les de første sidene av denne artikkelen fra Stanford om noen praktiske bruksområder for logistisk regresjon. Tenk på oppgaver som egner seg bedre for den ene eller den andre typen regresjonsoppgaver som vi har studert så langt. Hva ville fungert best?

Oppgave

Prøv denne regresjonen på nytt

Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

22 KiB Raw Permalink Blame History