Tweet Share Share
Sist Oppdatert 31. August 2020
multi-label klassifisering innebærer å forutsi null eller flere klasseetiketter.
I Motsetning til normale klassifiseringsoppgaver der klasseetiketter er gjensidig utelukkende, krever multi-label klassifisering spesialiserte maskinlæringsalgoritmer som støtter å forutsi flere gjensidig ikke-eksklusive klasser eller » etiketter.»
Deep learning nevrale nettverk er et eksempel på en algoritme som støtter multi-label klassifisering problemer. Nevrale nettverksmodeller for klassifiseringsoppgaver med flere etiketter kan enkelt defineres og evalueres ved Hjelp Av Keras deep learning library.
i denne opplæringen vil du oppdage hvordan du utvikler dype læringsmodeller for multi-label klassifisering.
etter å ha fullført denne opplæringen, vil du vite:
- multi-label klassifisering Er en prediktiv modelleringsoppgave som innebærer å forutsi null eller flere gjensidig ikke-eksklusive klasseetiketter.
- Nevrale nettverksmodeller kan konfigureres for klassifiseringsoppgaver med flere etiketter.
- hvordan evaluere et nevralt nettverk for multi-label klassifisering og lage en prediksjon for nye data.
La oss komme i gang.
Multi-Label Klassifisering Med Dyp Læring
Foto Av Trevor Marron, noen rettigheter reservert.
Opplæringsoversikt
denne opplæringen er delt inn i tre deler; de er:
- Klassifisering Med Flere Etiketter
- Nevrale Nettverk For Flere Etiketter
- Nevrale Nettverk For Flere Etiketter
Klassifisering er et prediktiv modelleringsproblem som innebærer å skrive ut en klasseetikett gitt noen inndata
Det er forskjellig fra regresjonsoppgaver som involver forutsi en numerisk verdi.
vanligvis innebærer en klassifiseringsoppgave å forutsi en enkelt etikett. Alternativt kan det innebære å forutsi sannsynligheten over to eller flere klasseetiketter. I disse tilfellene er klassene gjensidig utelukkende, noe som betyr at klassifiseringsoppgaven antar at inngangen bare tilhører en klasse.
noen klassifiseringsoppgaver krever å forutsi mer enn en klasseetikett. Dette betyr at klasse etiketter eller klasse medlemskap ikke er gjensidig utelukkende. Disse oppgavene er referert til som multiple label klassifisering, eller multi-label klassifisering for kort.
i multi-label klassifisering kreves null eller flere etiketter som utgang for hver inngangsprøve, og utgangene kreves samtidig. Forutsetningen er at utgangsetikettene er en funksjon av inngangene.
vi kan lage et syntetisk multi-label klassifiseringsdatasett ved hjelp av make_multilabel_classification () – funksjonen i scikit-learn-biblioteket.
vårt datasett vil ha 1000 prøver med 10 inngangsfunksjoner. Datasettet vil ha tre klasse etikettutganger for hver prøve, og hver klasse vil ha en eller to verdier (0 eller 1, f.eks.
det komplette eksempelet på å opprette og oppsummere det syntetiske klassifiseringsdatasettet med flere etiketter er oppført nedenfor.
|
1
2
3
4
5
6
7
8
9
|
# eksempel på en klassifiseringsoppgave med flere etiketter
fra sklearn.datasett import make_multilabel_classification
# definere datasett
X, y = make_multilabel_classification (n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
# oppsummer datasettfigur
skriv ut (x. form, y.figur)
# oppsummer første få eksempler
for jeg i rekkevidde(10):
skriv Ut (X, y)
|
Kjører eksemplet oppretter datasettet og oppsummerer formen på inngangs-og utgangselementene.
Vi kan se at det som forventet er 1000 prøver, hver med 10 inngangsfunksjoner og tre utgangsfunksjoner.
de første 10 radene med innganger og utganger er oppsummert, og vi kan se at alle innganger for dette datasettet er numeriske og at utgangsklasseetiketter har 0 eller 1 verdier for hver av de tre klasseetikettene.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
(1000, 10) (1000, 3)
|
Neste, la oss se på hvordan vi kan utvikle nevrale nettverksmodeller for multi-label klassifiseringsoppgaver.
Nevrale Nettverk For Flere Etiketter
noen maskinlæringsalgoritmer støtter multi-label klassifisering innfødt.
Nevrale nettverksmodeller kan konfigureres til å støtte multi-label klassifisering og kan utføre godt, avhengig av spesifikkene til klassifiseringsoppgaven.
multi-label klassifisering kan støttes direkte av nevrale nettverk ved å spesifisere antall måletiketter det er i problemet som antall noder i utgangslaget. For eksempel vil en oppgave som har tre utdataetiketter (klasser) kreve et nevralt nettverksutgangslag med tre noder i utdatalaget.
Hver node i utgangslaget må bruke sigmoid-aktiveringen. Dette vil forutsi en sannsynlighet for klassemedlemskap for etiketten, en verdi mellom 0 og 1. Til slutt må modellen passe med binary cross-entropy loss-funksjonen.
oppsummert, for å konfigurere en nevral nettverksmodell for multi-label klassifisering, er detaljene:
- Antall noder i utgangslaget samsvarer med antall etiketter.
- Sigmoid-aktivering for hver node i utgangslaget.
- Binær kryss-entropi tap funksjon.
Vi kan demonstrere dette ved Hjelp Av Keras deep learning library.
vi vil definere EN FLERLAGS Perceptron (MLP) modell for multi-label klassifisering oppgaven definert i forrige avsnitt.
Hver prøve har 10 innganger og tre utganger; derfor krever nettverket et inngangslag som forventer 10 innganger spesifisert via «input_dim» – argumentet i det første skjulte laget og tre noder i utgangslaget.
vi vil bruke den populære ReLU-aktiveringsfunksjonen i det skjulte laget. Det skjulte laget har 20 noder som ble valgt etter noen prøving og feiling. Vi vil passe modellen ved hjelp av binary cross-entropi tap og Adam versjon av stokastisk gradient descent.
definisjonen av nettverket for multi-label klassifisering oppgaven er oppført nedenfor.
|
1
2
3
4
5
|
# definer modellen
modell = Sekvensiell()
modell.legg til(Tett (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.legg til(Tett (n_outputs, aktivering=’sigmoid’))
modell.kompilere (tap= ‘binary_crossentropy’, optimizer = ‘adam’)
|
du vil kanskje tilpasse denne modellen til din egen multi-label klassifisering oppgave; derfor kan vi opprette en funksjon for å definere og returnere modellen der antall input og output variabler er gitt som argumenter.
|
1
2
3
4
5
6
7
|
# få modellen
def get_model (n_inputs, n_outputs):
modell = Sekvensiell ()
modell.legg til(Tett (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.legg til(Tett (n_outputs, aktivering=’sigmoid’))
modell.kompilere (tap=’binary_crossentropy’, optimizer=’adam’)
retur modell
|
Nå som vi er kjent med hvordan du definerer EN MLP for multi-label klassifisering, la oss utforske hvordan denne modellen kan evalueres.
Nevralt Nettverk For Klassifisering Med Flere Etiketter
hvis datasettet er lite, er det lurt å evaluere nevrale nettverksmodeller gjentatte ganger på samme datasett og rapportere gjennomsnittlig ytelse på tvers av repetisjonene.
Dette er på grunn av den stokastiske naturen til læringsalgoritmen.
I Tillegg er det god praksis å bruke k-fold kryssvalidering i stedet for tog / test deler av et datasett for å få et objektivt estimat av modellytelse når du gjør spådommer på nye data. Igjen, bare hvis det ikke er for mye data at prosessen kan fullføres innen rimelig tid.
Med dette i betraktning vil VI evaluere MLP-modellen på multi-output regresjonsoppgaven ved å bruke gjentatt k-fold kryssvalidering med 10 bretter og tre repetisjoner.
MLP-modellen vil forutsi sannsynligheten for hver klasse etikett som standard. Dette betyr at det vil forutsi tre sannsynligheter for hver prove. Disse kan konverteres til skarpe klasseetiketter ved å avrunde verdiene til enten 0 eller 1. Vi kan da beregne klassifiseringsnøyaktigheten for de skarpe klassetikettene.
|
1
2
3
4
5
6
7
|
…
# lag en prediksjon på testsettet
yhat = modell.forutsi (X_test)
# runde sannsynligheter til klasseetiketter
yhat = yhat.rund ()
# beregn nøyaktighet
acc = accuracy_score (y_test, yhat)
|
resultatene samles inn og kan oppsummeres ved å rapportere gjennomsnittlig og standardavvik på tvers av alle repetisjoner og kryssvalideringsfeller.
evaluate_model () – funksjonen nedenfor tar datasettet, evaluerer modellen og returnerer en liste over evalueringsresultater, i dette tilfellet nøyaktighetsresultater.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
# evaluer en modell med gjentatt k-fold kryssvalidering
def evaluate_model (X, y) :
resultater = liste ()
n_inputs, n_outputs = x. form, y. form
# definer evalueringsprosedyre
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# oppsummer folder
for train_ix, test_ix i cv.splitt(X):
# klargjør data
X_train, X_test = X, x
# definer modell
modell = get_model(n_inputs, n_outputs)
# fit Modell
modell.passer(X_train, y_train, verbose=0, epoker=100)
# lag en prediksjon på testsettet
yhat = modell.forutsi (X_test)
# runde sannsynligheter til klasseetiketter
yhat = yhat.rund ()
# beregn nøyaktighet
acc = accuracy_score (y_test, yhat)
# butikkresultat
skriv ut (‘>%.3f ‘ % acc)
resultater.tilføy (acc)
returnere resultater
|
Vi kan deretter laste inn vårt datasett og evaluere modellen og rapportere gjennomsnittlig ytelse.
Binder dette sammen, det komplette eksemplet er oppført nedenfor.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
# mlp for multi-label klassifisering
fra numpy import betyr
fra numpy import std
fra sklearn.datasett import make_multilabel_classification
fra sklearn.model_selection importer RepeatedKFold
fra keras.modeller importerer Sekvensiell
fra keras.lag importerer Tett
fra sklearn.metrics import accuracy_score
# få datasettet
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
retur x, y
# få modellen
def get_model(n_inputs, n_outputs):
modell = sekvensiell()
modell.legg til(Tett (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.legg til(Tett (n_outputs, aktivering=’sigmoid’))
modell.kompilere(tap=’binary_crossentropy’, optimizer=’adam’)
retur modell
# evaluer en modell ved å bruke gjentatt k-fold kryssvalidering
def evaluate_model (X, y):
resultater = liste ()
n_inputs, n_outputs = x. form, y.form
# definer evalueringsprosedyre
cv = RepeatedKFold (n_splits=10, n_repeats=3, random_state=1)
# oppsummer folder
for train_ix, test_ix i cv.splitt(X):
# klargjør data
X_train, X_test = X, x
# definer modell
modell = get_model(n_inputs, n_outputs)
# fit Modell
modell.passer(X_train, y_train, verbose=0, epoker=100)
# lag en prediksjon på testsettet
yhat = modell.forutsi (X_test)
# runde sannsynligheter til klasseetiketter
yhat = yhat.rund ()
# beregn nøyaktighet
acc = accuracy_score (y_test, yhat)
# butikkresultat
skriv ut (‘>%.3f ‘ % acc)
resultater.legg til(acc)
retur resultater
# last datasett
x, y = get_dataset()
# evaluer modell
resultater = evaluer_model(x, y)
# oppsummer ytelse
skriv ut(‘nøyaktighet: %.3f (%.3f) ‘ % (gjennomsnitt(resultater), std (resultater)))
|
Kjører eksemplet rapporterer klassifiseringsnøyaktigheten for hver fold og hver gjentakelse, for å gi en ide om evalueringsfremdriften.
Merk: resultatene dine kan variere gitt stokastisk karakter av algoritmen eller evalueringsprosedyren, eller forskjeller i numerisk presisjon. Vurder å kjøre eksemplet et par ganger og sammenlign gjennomsnittlig utfall.
på slutten rapporteres gjennomsnittlig og standardavviksnøyaktighet. I dette tilfellet er modellen vist å oppnå en nøyaktighet på ca 81,2 prosent.
du kan bruke denne koden som en mal for å evaluere MLP-modeller på dine egne klassifiseringsoppgaver med flere etiketter. Antall noder og lag i modellen kan enkelt tilpasses og tilpasses kompleksiteten i datasettet.
|
1
2
3
4
5
6
7
|
…
>0.780
>0.820
>0.790
>0.810
>0.840
Nøyaktighet: 0.812 (0.032)
|
Når en modellkonfigurasjon er valgt, kan vi bruke den til å passe en endelig modell på alle tilgjengelige data og lage en prediksjon for nye data.
eksemplet nedenfor viser dette ved først å tilpasse MLP-modellen på hele klassifiseringsdatasettet med flere etiketter, og deretter kalle predict () – funksjonen på den lagrede modellen for å lage en prediksjon for en ny datarad.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
# bruk mlp for prediksjon på multi-label klassifisering
fra numpy import asarray
fra sklearn.datasett import make_multilabel_classification
fra keras.modeller importerer Sekvensiell
fra keras.lag import Tett
# få datasettet
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
retur x, Y
# få modellen
def get_model(n_inputs, n_outputs):
modell = sekvensiell()
modell.legg til(Tett (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.legg til(Tett (n_outputs, aktivering=’sigmoid’))
modell.kompilere(tap=’binary_crossentropy’, optimizer=’adam’)
retur modell
# last datasett
x, y = get_dataset()
n_inputs, n_outputs = x. form, y.form
# få modell
modell = get_model(n_inputs, n_outputs)
# monter modellen på alle data
modell.passer (X, y, verbose = 0, epoker=100)
# lag en prediksjon for nye data
row =
newX = asarray()
yhat = modell.forutsi (newX)
skriv ut (‘Spådd: %s’ % yhat)
|
Kjører eksemplet passer til modellen og gjør en prediksjon for en ny rad. Som forventet inneholder prediksjonen tre utdatavariabler som kreves for klassifiseringsoppgaven med flere etiketter: sannsynlighetene for hver klasseetikett.
|
1
|
Spådd:
|
Videre Lesing
Denne delen gir flere ressurser om emnet hvis du ønsker å gå dypere.
- klassifisering Med Flere etiketter, Wikipedia.
- sklearn.datasett.make_multilabel_classification API.
- Keras hjemmeside.
- sklearn.model_selection.RepeatedStratifiedKFold API.
Sammendrag
i denne opplæringen oppdaget du hvordan du kan utvikle dype læringsmodeller for multi-label klassifisering.
spesielt lærte Du:
- multi-label klassifisering Er en prediktiv modelleringsoppgave som innebærer å forutsi null eller flere gjensidig ikke-eksklusive klasseetiketter.
- Nevrale nettverksmodeller kan konfigureres for klassifiseringsoppgaver med flere etiketter.
- hvordan evaluere et nevralt nettverk for multi-label klassifisering og lage en prediksjon for nye data.
har du noen spørsmål?
Still dine spørsmål i kommentarene nedenfor, og jeg vil gjøre mitt beste for å svare.
Utvikle Dype Læringsprosjekter med Python!
Hva Om Du Kunne Utvikle Et Nettverk på Få Minutter
…Med bare noen få Linjer Med Python
Oppdag hvordan i min nye Ebok:
Deep Learning With Python
den dekker ende-til-ende-prosjekter på emner som:
Flerskikts Perceptroner, Konvolusjonsnett og Tilbakevendende Nevrale Nett, og mer…
Ta Endelig Dyp Læring Til
Dine Egne Prosjekter
Hopp Over Akademikerne. Bare Resultater.
Se Hva Som Er Inni
Tweet Share Share
