Campus Recruitment: A Classification Problem With Logistic Regression

Ponovno objavil Platon

Spremljevalci: 0

Predstavitev

V tem projektu se bomo osredotočili na podatke iz Indije. In naš cilj je ustvariti a napovedni model, kot je logistična regresija itd., tako da lahko model, ko podamo značilnosti kandidata, napove, ali bo zaposlil.

O nabor podatkov se vrti okoli sezone pripravništva na poslovni šoli v Indiji. Nabor podatkov vsebuje različne dejavnike o kandidatih, kot so delovne izkušnje, odstotek opravljenih izpitov itd. Končno vsebuje status zaposlovanja in podrobnosti o plačilu.

Problem podatkovne znanosti z logistično regresijo

Zaposlovanje v kampusu je strategija za pridobivanje, angažiranje in zaposlovanje mladih talentov za pripravništvo in začetna delovna mesta. Pogosto vključuje sodelovanje z univerzitetnimi centri za karierne storitve in obiskovanje kariernih sejmov za osebno srečanje s študenti in nedavnimi diplomanti.

Ta članek je bil objavljen kot del Blogaton podatkovne znanosti.

Kazalo

Koraki, vključeni v rešitev težave

V tem članku bomo uvozili ta nabor podatkov, ga očistili in nato pripravili za izdelavo modela logistične regresije. Naši cilji tukaj so naslednji:

Najprej bomo pripravili naš nabor podatkov za binarna klasifikacija. Zdaj, kaj mislim? ko poskušamo napovedati stalno vrednost, kot je cena stanovanja, je to lahko poljubno število med nič in več milijoni dolarjev. Imenujemo ga regresijski problem.

Toda v tem projektu so stvari nekoliko drugačne. Namesto predvidevanja zvezne vrednosti imamo diskretne skupine ali razrede, ki jih poskušamo predvideti med njimi. To se torej imenuje problem klasifikacije in ker bomo v našem projektu imeli samo dve skupini, med katerima poskušamo izbirati, je to binarna klasifikacija.

Drugi cilj je ustvariti logistični regresijski model za napovedovanje zaposlovanja. In naš tretji cilj je razložiti napovedi našega modela z uporabo razmerja obetov.

Kar zadeva potek dela strojnega učenja, korake, ki jim bomo sledili, in nekaj novih stvari, ki se jih bomo naučili na poti. Tako bomo v fazi uvoza naše podatke pripravili za delo z binarnim ciljem. V fazi raziskovanja si bomo ogledali razredno ravnotežje. Torej, v bistvu, kakšen delež kandidatov je bil zavrnjen in kateri delež ne? in v fazi kodiranja značilnosti bomo izvedli kodiranje naših kategoričnih značilnosti. V razdeljenem delu bomo izvedli naključni testni del vlaka.

Za fazo izdelave modela bomo najprej postavili svojo osnovo in ker bomo uporabili ocene točnosti, bomo več govorili o tem, kaj je ocena natančnosti in kako zgraditi osnovo, ko je to metrika, ki nas zanima. Drugič, delali bomo logistično regresijo. In ne nazadnje, imeli bomo fazo ocenjevanja. Ponovno se bomo osredotočili na oceno točnosti. Nazadnje, da bi sporočili rezultate, si bomo ogledali razmerje obetov.

Nazadnje, preden se poglobimo v delo, se predstavimo knjižnicam, ki jih bomo uporabljali za projekt. Najprej bomo svoje podatke uvozili v Google Colabe notebook v knjižnico io. Potem, ko bomo uporabili logistični regresijski model, ga bomo uvozili iz scikit-learn. Po tem tudi od scikit-učiti, bomo uvozili naše meritve uspešnosti, oceno točnosti in razdelek train-test-split.

Uporabili bomo matplotlib in rojen v morju za našo vizualizacijo, in numpy bo samo za malo matematike.
Potrebujemo pand za manipulacijo naših podatkov, labelenkoder za kodiranje naših kategoričnih spremenljivk in standardni skalirnik za normalizacijo podatkov. To bodo knjižnice, ki jih potrebujemo.

Pojdimo k pripravi podatkov.

#import libraries
import io
import warnings import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler warnings.simplefilter(action="ignore", category=FutureWarning)

Pripravite podatke

uvoz

Za začetek priprave podatkov se lotimo našega pomembnega dela. Najprej naložimo našo podatkovno datoteko, nato pa jih moramo dati v DataFrame `df.`

from google.colab import files
uploaded = files.upload()

# Read CSV file
df = pd.read_csv(io.BytesIO(uploaded["Placement_Data_Full_Class.csv"]))
print(df.shape)
df.head()

Vidimo lahko naš čudovit DataFrame in imamo 215 zapisov in 15 stolpcev, ki vključujejo atribut `status`, naš cilj. To je opis za vse funkcije.

Razišči

Zdaj imamo vse te funkcije, ki jih bomo raziskali. Pa začnimo našo raziskovalne analize podatkov. Najprej si oglejmo informacije za ta podatkovni okvir in ugotovimo, ali moramo katerega od njih obdržati ali pa ga moramo morda opustiti.

# Inspect DataFrame
df.info() <class 'pandas.core.frame.DataFrame'>
RangeIndex: 215 entries, 0 to 214
Data columns (total 15 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 sl_no 215 non-null int64 1 gender 215 non-null object 2 ssc_p 215 non-null float64 3 ssc_b 215 non-null object 4 hsc_p 215 non-null float64 5 hsc_b 215 non-null object 6 hsc_s 215 non-null object 7 degree_p 215 non-null float64 8 degree_t 215 non-null object 9 workex 215 non-null object 10 etest_p 215 non-null float64 11 specialisation 215 non-null object 12 mba_p 215 non-null float64 13 status 215 non-null object 14 salary 148 non-null float64
dtypes: float64(6), int64(1), object(8)
memory usage: 25.3+ KB

Zdaj, ko pogledamo podatke `df`, iščemo nekaj stvari, v našem podatkovnem okviru imamo 215 vrstic in vprašanje, ki si ga želimo zastaviti, je, ali manjkajo kakšni podatki? In če pogledamo sem, se zdi, da nimamo manjkajočih podatkov, razen stolpca za plače, kot je bilo pričakovano, zaradi kandidatov, ki niso bili zaposleni.

Druga skrb, ki nas skrbi tukaj, je, ali obstajajo kakšne puščajoče funkcije, ki bi našemu modelu dale informacije, ki jih ne bi imel, če bi bil nameščen v resničnem svetu? Ne pozabite, da želimo, da naš model napove, ali se bo kandidat uvrstil ali ne, in želimo, da naš model naredi te napovedi, preden pride do zaposlovanja. Zato po zaposlitvi ne želimo dajati nobenih informacij o teh kandidatih.

Torej je precej jasno, da ta funkcija `plača` daje informacije o plači, ki jo ponuja podjetje. In ker je ta plača za tiste, ki so sprejeti, ta funkcija tukaj predstavlja uhajanje in jo moramo opustiti.

df.drop(columns="salary", inplace=True)

Druga stvar, ki jo želim pogledati, so tipi podatkov za te različne funkcije. Torej, če pogledamo te vrste podatkov, imamo osem kategoričnih značilnosti z našim ciljem in sedem numeričnih značilnosti, in vse je pravilno. Zdaj, ko imamo te ideje, si vzemimo nekaj časa, da jih globlje raziščemo.

Vemo, da ima naš cilj dva razreda. Kandidate smo postavljali in ne kandidatov. Vprašanje je, kakšen je relativni delež teh dveh razredov? Ali sta približno enaka? Ali pa je eno veliko več kot drugo? To je nekaj, kar morate pogledati, ko delate težave s klasifikacijo. To je torej pomemben korak v naši EDA.

# Plot class balance
df["status"].value_counts(normalize=True).plot( kind="bar", xlabel="Class", ylabel="Relative Frequency", title="Class Balance"
);

Razredno neravnovesje za logistično regresijo

Naš pozitivni razred 'uvrščen' šteje več kot 65 % naših opazovanj, naš negativni razred 'neuvrščen' pa okoli 30 %. Zdaj, če bi bili ti super neuravnoteženi, na primer, če bi bilo približno 80 ali celo več kot to, bi rekel, da so to neuravnoteženi razredi. In morali bi narediti nekaj dela, da zagotovimo, da bo naš model deloval na pravi način. Ampak to je v redu ravnotežje.

Naredimo še eno vizualizacijo, da opazimo povezavo med našimi lastnostmi in tarčo. Začnimo z numeričnimi značilnostmi.

Najprej bomo videli posamezno porazdelitev značilnosti z uporabo distribucijskega grafa, prav tako pa bomo videli razmerje med numeričnimi značilnostmi in našim ciljem z uporabo škatlastega grafa.

fig,ax=plt.subplots(5,2,figsize=(15,35))
for index,i in enumerate(df.select_dtypes("number").drop(columns="sl_no")): plt.suptitle("Visualizing Distribution of Numerical Columns Indivualy and by Class",size=20) sns.histplot(data=df, x=i, kde=True, ax=ax[index,0]) sns.boxplot(data=df, x='status', y=i, ax=ax[index,1]);

V prvem stolpcu našega grafa lahko vidimo, da vse porazdelitve sledijo normalni porazdelitvi in da je večina kandidatovih izobraževalnih uspehov med 60-80 %.

V drugem stolpcu imamo dvojni okvir z razredom 'Placed' na desni in nato razred 'Not Placed' na levi. Za funkcije 'etest_p' in 'mba_p' ni velike razlike v teh dveh distribucijah z vidika gradnje modela. Porazdelitev po razredih se precej prekriva, zato te lastnosti ne bi bile dober napovedovalec našega cilja. Kar zadeva ostale funkcije, so dovolj izrazite, da jih jemljemo kot potencialne dobre napovednike našega cilja. Pojdimo k kategoričnim značilnostim. Da bi jih raziskali, bomo uporabili graf štetja.

fig,ax=plt.subplots(7,2,figsize=(15,35))
for index,i in enumerate(df.select_dtypes("object").drop(columns="status")): plt.suptitle("Visualizing Count of Categorical Columns",size=20) sns.countplot(data=df,x=i,ax=ax[index,0]) sns.countplot(data=df,x=i,ax=ax[index,1],hue="status")

Če pogledamo zaplet, vidimo, da imamo več moških kandidatov kot žensk. In večina naših kandidatov nima nobenih delovnih izkušenj, vendar so ti kandidati dobili več zaposlitev kot tisti, ki so jih imeli. Imamo kandidate, ki so opravili komercialni tečaj kot tečaj 'hsc', poleg dodiplomskega študija pa so kandidati z naravoslovnim ozadjem v obeh primerih drugi najvišji.

Majhna opomba o modelih logistične regresije, čeprav so namenjeni razvrščanju, so v isti skupini kot drugi linearni modeli, kot je linearna regresija, in iz tega razloga, ker sta oba linearna modela. Skrbeti nas mora tudi vprašanje multikolinearnosti. Ustvariti moramo korelacijsko matriko, nato pa jo moramo izrisati v toplotni zemljevid. Tu si ne želimo ogledati vseh funkcij, ampak le numerične značilnosti in ne želimo vključiti našega cilja. Če je naš cilj v korelaciji z nekaterimi našimi lastnostmi, je to zelo dobro.

corr = df.select_dtypes("number").corr()
# Plot heatmap of `correlation`
plt.title('Correlation Matrix')
sns.heatmap(corr, vmax=1, square=True, annot=True, cmap='GnBu');

Tu sta svetlo modra, ki pomeni malo ali nič korelacije, in temno modra, s katero imamo večjo korelacijo. Zato želimo biti pozorni na tiste temno modre. Vidimo lahko temno modro črto, diagonalno črto, ki poteka po sredini te ploskve. To so lastnosti, ki so povezane same s seboj. In potem vidimo nekaj temnih kvadratov. To pomeni, da imamo med funkcijami kup korelacij.

V zadnjem koraku našega EDA moramo preveriti visoko-nizko kardinalnost v kategoričnih značilnostih. Kardinalnost se nanaša na število edinstvenih vrednosti v kategorični spremenljivki. Visoka kardinalnost pomeni, da imajo kategorične značilnosti veliko število edinstvenih vrednosti. Ni natančnega števila edinstvenih vrednosti, zaradi katerih ima funkcija visoko kardinalnost. Če pa je vrednost kategorične značilnosti edinstvena za skoraj vsa opazovanja, jo je običajno mogoče opustiti.

# Check for high- and low-cardinality categorical features
df.select_dtypes("object").nunique() gender 2
ssc_b 2
hsc_b 2
hsc_s 3
degree_t 3
workex 2
specialisation 2
status 2
dtype: int64

Ne vidim nobenega stolpca, v katerem bi bilo število edinstvenih vrednosti ena ali kar koli zelo visoko. Ampak mislim, da tukaj manjka en stolpec kategoričnega tipa. In razlog je v tem, da ni kodiran kot objekt, ampak kot celo število. Stolpec 'sl_no' ni celo število v znanem pomenu. Ti kandidati so razvrščeni po določenem vrstnem redu. Samo edinstvena imenska oznaka in ime je kot kategorija, kajne? To je torej kategorična spremenljivka. In nima nobenih informacij, zato ga moramo izpustiti.

df.drop(columns="sl_no", inplace=True)

Značilnosti kodiranja

Končali smo našo analizo in naslednja stvar, ki jo moramo narediti, je kodiranje naših kategoričnih značilnosti, uporabil bom 'LabelEncoder'. Kodiranje oznak je priljubljena tehnika kodiranja za ravnanje s kategoričnimi spremenljivkami. Z uporabo te tehnike je vsaki oznaki dodeljeno edinstveno celo število na podlagi abecednega vrstnega reda.

lb = LabelEncoder () cat_data = ['gender', 'ssc_b', 'hsc_b', 'hsc_s', 'degree_t', 'workex', 'specialisation', 'status']
for i in cat_data: df[i] = lb.fit_transform(df[i]) df.head()

Split

Podatke smo uvozili in očistili. Opravili smo malo raziskovalne analize podatkov, zdaj pa moramo razdeliti naše podatke. Imamo dve vrsti razdelitve: navpično razdelitev ali ciljne funkcije in vodoravno razdelitev ali testne nize. Začnimo z navpičnim. Ustvarili bomo našo značilno matriko 'X' in ciljni vektor 'y'. Naš cilj je "status". Naše značilnosti bi morali biti vsi stolpci, ki ostanejo v 'df.'

#vertical split
target = "status"
X = df.drop(columns = target)
y = df[target]

Modeli na splošno delujejo bolje, če imajo normalizirane podatke za usposabljanje, kaj je torej normalizacija? Normalizacija preoblikuje vrednosti več spremenljivk v podobno območje. Naš cilj je normalizirati naše spremenljivke. Njihovi razponi vrednosti bodo torej od 0 do 1. Naredimo to in uporabil bom `StandardScaler`.

scaler = StandardScaler()
X = scaler.fit_transform(X)

Zdaj pa izvedimo nize vodoravnega split-a ali treninga. Naše podatke (X in y) moramo razdeliti na nabore za usposabljanje in teste z uporabo naključne razdelitve vlak-test. naš testni niz bi moral predstavljati 20 % vseh naših podatkov. In ne pozabimo nastaviti random_state za ponovljivost.

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size = 0.2, random_state = 42 ) print("X_train shape:", X_train.shape)
print("y_train shape:", y_train.shape)
print("X_test shape:", X_test.shape)
print("y_test shape:", y_test.shape) X_train shape: (172, 12)
y_train shape: (172,)
X_test shape: (43, 12)
y_test shape: (43,)

Zgradite model logistične regresije

Izhodišče

Zdaj moramo torej začeti graditi naš model in začeti bomo morali naročati, da nastavimo svojo osnovno linijo. Ne pozabite, da je vrsta problema, s katerim se ukvarjamo, problem klasifikacije in obstajajo različne metrike za vrednotenje modelov klasifikacije. Tisto, na kar se želim osredotočiti, je ocena točnosti.

Kakšna je ocena točnosti? Ocena natančnosti pri strojnem učenju je metrika vrednotenja, ki meri število pravilnih napovedi modela glede na skupno število izvedenih napovedi. Izračunamo ga tako, da število pravilnih napovedi delimo s skupnim številom napovedi. To torej pomeni, da gre ocena natančnosti med 0 in 1. Nič ni dobra. Tam si ne želiš biti in eden je popoln. Zato imejmo to v mislih in ne pozabimo, da je izhodiščna linija model, ki vedno znova daje eno napoved, ne glede na to, kakšno je opazovanje, za nas pa le eno ugibanje.

V našem primeru imamo dva razreda, postavljena ali ne. Torej, če bi lahko naredili samo eno napoved, kakšna bi bila naša ena ugibanja? Če ste rekli večinski razred. Mislim, da je to smiselno, kajne? Če imamo lahko samo eno napoved, bi verjetno morali izbrati tisto z najvišjimi opazovanji v našem naboru podatkov. Torej bo naše izhodišče uporabilo odstotek, ki ga večinski razred prikaže v podatkih o usposabljanju. Če model ne presega te osnovne vrednosti, funkcije ne dodajajo dragocenih informacij za razvrščanje naših opažanj.

Za izračun osnovne natančnosti lahko uporabimo metodo 'value_counts' z argumentom 'normalize = True':

acc_baseline = y_train.value_counts(normalize=True).max()
print("Baseline Accuracy:", round(acc_baseline, 2)) Baseline Accuracy: 0.68

Vidimo lahko, da je naša osnovna natančnost 68 % ali 0.68 kot delež. Da bi dodali vrednost, da bi bila uporabna, želimo preseči to številko in se približati ena. To je naš cilj, zdaj pa začnimo graditi naš model.

Ponovite

Zdaj je čas, da zgradimo naš model z uporabo logistične regresije. Uporabili bomo logistično regresijo, a preden to storimo, se pogovorimo malo o tem, kaj je logistična regresija in kako deluje, nato pa se lahko lotimo kodiranja. In za to imamo tukaj majhno mrežo.

Recimo, da imam p_degrees kandidatov v našem naboru podatkov vzdolž osi x. In ko se premikam od desne proti levi, so stopinje vse višje in nato vzdolž osi Y imam možne razrede za umestitev: nič in ena.

Torej, če bi narisali naše podatkovne točke, kako bi to izgledalo? Naša analiza kaže, da je verjetneje, da bodo zaposlili kandidata z visoko stopnjo `p_degree`. Torej bi verjetno izgledalo nekako takole, kjer bi bil kandidat z majhno `p_degree` nižjo vrednostjo. In kandidat z visoko `p_degree` bi dosegel eno.

Zdaj pa recimo, da smo s tem želeli narediti linearno regresijo. Recimo, da smo želeli narisati črto.
Zdaj, če bi to naredili, bi se zgodilo to, da bi bila ta črta narisana tako, da bi poskušala biti čim bližje vsem točkam. In tako bi verjetno končali s črto, ki bi izgledala nekako takole. Bi bil to dober model?

res ne. Kar bi se zgodilo, je, da ne glede na p_degree kandidata vedno dobimo nekakšno vrednost. In to nam ne bo pomagalo, ker številke v tem kontekstu ne pomenijo ničesar. Ta težava s klasifikacijo mora biti nič ali ena. Torej, tako ne bo šlo.

Po drugi strani, ker je to črta, kaj če imamo kandidata z zelo nizko p_degree? No, kar naenkrat je naša ocena negativno število. In spet, to nima nobenega smisla. Nobenega negativnega števila ni, mora biti nič ali ena. In na enak način, če imamo kandidata z zelo visoko stopnjo p_degree, bi lahko imel pozitivno, nekaj nad ena. In spet, to nima nobenega smisla. Imeti moramo bodisi ničlo bodisi ena.

Tukaj torej vidimo nekaj resnih omejitev uporabe linearne regresije za klasifikacijo. Torej, kaj moramo storiti? Ustvariti moramo model številka ena: ne gre pod ničlo ali nad ena, zato mora biti vezan med ničlo in ena. In številka dve, kar koli izhaja iz te funkcije, te enačbe, ki jo ustvarimo, tega morda ne bi smeli obravnavati kot napoved samo po sebi, temveč kot korak k naši končni napovedi.

Zdaj pa naj razpakiram, kar sem pravkar rekel, in spomnimo se, da ko delamo svoje modele linearne regresije, končamo s to linearno enačbo, ki je najpreprostejša oblika. In to je tista enačba ali funkcija, ki nam daje to ravno črto.

Obstaja način, kako to vrstico povezati med 0 in 1. Kar lahko storimo, je, da vzamemo to funkcijo, ki smo jo pravkar ustvarili, in jo zapremo v drugo funkcijo, tako imenovano sigmoidno funkcijo.

Torej, vzel bom linearno enačbo, ki smo jo pravkar imeli, in jo bom skrčil v sigmoidno funkcijo ter jo dal kot eksponento.

Zgodi se, da namesto ravne črte dobimo črto, ki izgleda nekako takole. Zataknilo se je pri enem. Pride noter in se zvija navzdol. Potem se zatakne na nič.

Tako je videti črta in vidimo, da smo rešili prvi problem. Karkoli dobimo iz te funkcije, bo med 0 in 1. V drugem koraku vsega, kar izhaja iz te enačbe, ne bomo obravnavali kot končno napoved. Namesto tega ga bomo obravnavali kot verjetnost.

kaj mislim To pomeni, da bom, ko naredim napoved, dobil neko vrednost s plavajočo vejico med 0 in 1. In to bom obravnaval kot verjetnost, da moja napoved spada v pozitivni razred.

Torej dobim vrednost na 0.9999. Rekel bom, da je verjetnost, da ta kandidat spada v naš pozitivno uvrščeni razred, 99-odstotna. Tako da sem skoraj prepričan, da spada v razred pozitivnih. Nasprotno, če pade na točko 0.001 ali kar koli drugega, bom rekel, da je ta številka nizka. Verjetnost, da to posebno opazovanje pripada pozitivnemu, postavljenemu razredu, je skoraj enaka nič. In tako bom rekel, da spada v razred nič.

Torej je to smiselno za števila, ki so blizu ena ali blizu nič. Lahko pa se vprašate, kaj naj naredim z drugimi vrednotami vmes? To deluje tako, da postavimo mejno črto točno na 0.5, tako da vsako vrednost, ki jo dobim pod to črto, postavim na nič, tako da je moja napoved ne, in če je nad to črto, če je nad točko pet , to bom uvrstil v razred pozitivnih, moja napoved je ena.

Torej, zdaj imam funkcijo, ki mi daje napoved med nič in ena, in to obravnavam kot verjetnost. In če je ta verjetnost nad 0.5 ali 50 %, rečem, v redu, pozitiven razred ena. In če je pod 50 %, pravim, da je to negativni razred, nič. To je torej način, kako deluje logistična regresija. In zdaj to razumemo, dajmo to kodirati in prilagoditi. Hiperparameter 'max_iter' bom nastavil na 1000. Ta parameter se nanaša na največje število ponovitev, ki jih morata reševalci konvergirati.

# Build model
model = LogisticRegression(max_iter=1000) # Fit model to training data
model.fit(X_train, y_train) LogisticRegression(max_iter=1000)

oceniti

Zdaj je čas, da vidimo, kako se obnese naš model. Čas je za oceno modela logistične regresije. Torej, zapomnimo si, da je tokrat metrika uspešnosti, ki nas zanima, rezultat natančnosti in želimo natančno oceno. In želimo preseči osnovno vrednost 0.68. Natančnost modela je mogoče izračunati s funkcijo accuracy_score. Funkcija zahteva dva argumenta, prave oznake in predvidene oznake.

acc_train = accuracy_score(y_train, model.predict(X_train))
acc_test = model.score(X_test, y_test) print("Training Accuracy:", round(acc_train, 2))
print("Test Accuracy:", round(acc_test, 2)) Training Accuracy: 0.9
Test Accuracy: 0.88

Vidimo, da je naša natančnost usposabljanja 90-odstotna. Premaga osnovno linijo. Natančnost našega testa je bila nekoliko nižja pri 88 %. Prav tako je presegla osnovno črto in je bila zelo blizu naše natančnosti treninga. To je torej dobra novica, ker to pomeni, da naš model ni preveč prilegajoč ali kaj podobnega.

Rezultati modela logistične regresije

Ne pozabite, da z logistično regresijo končamo s temi končnimi napovedmi nič ali ena. Toda pod to napovedjo obstaja verjetnost števila s plavajočo vejico med nič ali ena in včasih je lahko koristno videti, kakšne so te ocene verjetnosti. Poglejmo naše napovedi glede treninga in poglejmo prvih pet. Metoda 'predvidi' napove cilj neoznačenega opazovanja.

model.predict(X_train)[:5] array([0, 1, 1, 1, 1])

To so bile torej končne napovedi, toda kakšne so verjetnosti za njimi? Da jih dobimo, moramo narediti nekoliko drugačno kodo. Namesto uporabe metode `predict` z našim modelom bom uporabil 'predict_proba' z našimi podatki o usposabljanju.

y_train_pred_proba = model.predict_proba(X_train)
print(y_train_pred_proba[:5]) [[0.92003219 0.07996781] [0.03202019 0.96797981] [0.00678421 0.99321579] [0.03889446 0.96110554] [0.00245525 0.99754475]]

Vidimo lahko nekakšen ugnezdeni seznam z dvema različnima stolpcema v njem. Stolpec na levi predstavlja verjetnost, da kandidat ni uvrščen ali naš negativni razred 'Not Placed'. Drugi stolpec predstavlja pozitivni razred `Placed` ali verjetnost, da je kandidat uvrščen. Osredotočili se bomo na drugi stolpec. Če pogledamo prvo oceno verjetnosti desno, lahko vidimo, da je to 0.07. Torej, ker je to pod 50 %, pravi naš model, je moja napoved enaka nič. In za naslednje napovedi lahko vidimo, da so vse nad 0.5, in zato je naš model na koncu napovedal eno.

Zdaj želimo izluščiti imena in pomembnost funkcij ter jih postaviti v niz. In ker moramo pomembnost značilnosti prikazati kot razmerja obetov, moramo narediti le malo matematične transformacije, tako da vzamemo eksponent naše pomembnosti.

# Features names
features = ['gender', 'ssc_p', 'ssc_b', 'hsc_p', 'hsc_b', 'hsc_s', 'degree_p' ,'degree_t', 'workex', 'etest_p', 'specialisation', 'mba_p']
# Get importances
importances = model.coef_[0]
# Put importances into a Series
odds_ratios = pd.Series(np.exp(importances), index= features).sort_values()
# Review odds_ratios.head() mba_p 0.406590
degree_t 0.706021
specialisation 0.850301
hsc_b 0.876864
etest_p 0.877831
dtype: float64

Preden razpravljamo o razmerjih obetov in kaj so, jih poglejmo na vodoravni stolpčni grafikon. Za izdelavo risbe uporabimo pande in ne pozabimo, da bomo iskali pet največjih koeficientov. In ne želimo uporabiti vseh razmerij kvot. Torej želimo uporabiti rep.

# Horizontal bar chart, five largest coefficients
odds_ratios.tail().plot(kind="barh")
plt.xlabel("Odds Ratio")
plt.ylabel("Feature")
plt.title("High Importance Features");

# Vodoravni palični grafikon, pet največjih koeficientov odds_ratios.tail().plot(kind=

Zdaj si želim, da si zamislite navpično črto točno pri 5, in želim začeti tako, da jo pogledam. Pogovorimo se o vsakem od njih posebej ali samo o prvem paru. Začnimo torej s 'ssc_p', ki se nanaša na 'odstotek srednješolske izobrazbe – 10. razred'. In vidimo lahko, da je razmerje verjetnosti 30. Zdaj, kaj to pomeni? Če ima kandidat visok 'ssc_p', so možnosti za njegovo uvrstitev šestkrat večje kot pri drugih kandidatih, če so vse enake. Drugi način razmišljanja o tem je, da se, ko ima kandidat `ssc_p`, možnost, da se kandidat zaposli, šestkrat poveča.

Vsako razmerje kvot nad pet torej poveča kvote za uvrščanje kandidatov. In zato imamo tisto navpično črto pri petih. In teh pet vrst lastnosti so značilnosti, ki so najbolj povezane s povečanim zaposlovanjem. Torej, to je naše razmerje možnosti. Zdaj smo pogledali funkcije, ki so najbolj povezane s povečanjem zaposlovanja. Poglejmo značilnosti, ki so povezane z njim, zmanjšanjem zaposlovanja. Zdaj je čas, da pogledamo najmanjše. Torej, namesto da bi gledali rep, bomo gledali vanj.

odds_ratios.head().plot(kind="barh")
plt.xlabel("Odds Ratio")
plt.xlabel("Odds Ratio")
plt.ylabel("Feature")
plt.title("Low Importance Features");

Prva stvar, ki jo moramo tukaj videti, je, da opazite, da je na osi x vse ena ali nižja. Zdaj, kaj to pomeni? Oglejmo si torej naše najmanjše razmerje kvot. To je mba_p, ki se nanaša na odstotek MBA. Vidimo, da je pripravljen pri približno 0.45. Zdaj, kaj to pomeni? No, razlika med 0.45 in 1 je 0.55. V redu? In kaj ta številka pomeni? Tisti kandidati z MBA imajo za 55 % manjšo verjetnost, da bodo zaposleni. V redu? Tako se je verjetnost zaposlovanja zmanjšala za faktor 0.55 ali 55 %. In to velja za vse tukaj.

zaključek

Kaj smo se torej naučili? Najprej smo se v fazi priprave podatkov naučili, da delamo s klasifikacijo, natančneje z binarno klasifikacijo, z uporabo logistične regresije. Kar zadeva raziskovanje podatkov, smo naredili kup stvari, kar zadeva poudarke, pa smo si ogledali ravnovesje razredov, kajne? Delež naših pozitivnih in negativnih razredov. Nato svoje podatke razdelimo.

Ker je logistična regresija klasifikacijski model, smo izvedeli za novo metriko uspešnosti, oceno točnosti. Zdaj se ocena natančnosti giblje med 0 in 1. Nič je slabo, ena pa dobro. Ko smo ponavljali, smo se učili o logistični regresiji. To je čaroben način, kjer lahko vzamete linearno enačbo, ravno črto, in jo postavite v drugo funkcijo, sigmoidno funkcijo in aktivacijsko funkcijo, ter iz tega dobite oceno verjetnosti in to oceno verjetnosti spremenite v napoved.

Nazadnje smo izvedeli o razmerju kvot in načinu, kako lahko razlagamo koeficiente, da ugotovimo, ali bo določena lastnost povečala verjetnost, da smo zaposlili kandidata ali ne.

Izvorna koda projekta: https://github.com/SawsanYusuf/Campus-Recruitment.git

Mediji, prikazani v tem članku, niso v lasti Analytics Vidhya in se uporabljajo po lastni presoji avtorja.