Multi-label klassificering med Deep Learning

Tweet Share Share

Senast uppdaterad Augusti 31, 2020

Multi-label klassificering innebär att förutsäga noll eller flera klassetiketter.

till skillnad från normala klassificeringsuppgifter där klassetiketter utesluter varandra, kräver klassificering med flera etiketter specialiserade maskininlärningsalgoritmer som stöder att förutsäga flera ömsesidigt icke-exklusiva klasser eller ”etiketter.”

Deep learning neurala nätverk är ett exempel på en algoritm som naturligt stöder klassificeringsproblem med flera etiketter. Neurala nätverksmodeller för klassificeringsuppgifter med flera etiketter kan enkelt definieras och utvärderas med hjälp av keras deep learning library.

i denna handledning kommer du att upptäcka hur man utvecklar djupa inlärningsmodeller för klassificering med flera etiketter.

när du har slutfört denna handledning kommer du att veta:

  • Multi-label klassificering är en prediktiv modellering uppgift som innebär att förutsäga noll eller flera ömsesidigt icke-exklusiva klassetiketter.
  • neurala nätverksmodeller kan konfigureras för klassificeringsuppgifter med flera etiketter.
  • hur man utvärderar ett neuralt nätverk för klassificering med flera etiketter och gör en förutsägelse för nya data.

Låt oss komma igång.

 Multi-label klassificering med Deep Learning

Multi-Label klassificering med Deep Learning
foto av Trevor Marron, vissa rättigheter reserverade.

handledning Översikt

denna handledning är uppdelad i tre delar; de är:

  • klassificering med flera etiketter
  • neurala nätverk för flera etiketter
  • neurala nätverk för klassificering med flera etiketter

klassificering med flera etiketter

klassificering är ett prediktivt modelleringsproblem som innebär att man matar ut en klassetikett med viss inmatning

det skiljer sig från regressionsuppgifter det innebär att förutsäga ett numeriskt värde.

vanligtvis innebär en klassificeringsuppgift att förutsäga en enda etikett. Alternativt kan det innebära att förutsäga sannolikheten över två eller flera klassetiketter. I dessa fall är klasserna ömsesidigt exklusiva, vilket innebär att klassificeringsuppgiften förutsätter att inmatningen endast tillhör en klass.

vissa klassificeringsuppgifter kräver att man förutsäger mer än en klassetikett. Detta innebär att klassetiketter eller klassmedlemskap inte utesluter varandra. Dessa uppgifter kallas multipel etikettklassificering, eller multi-label klassificering för kort.

i klassificering med flera etiketter krävs noll eller flera etiketter som utgång för varje ingångsprov, och utgångarna krävs samtidigt. Antagandet är att utgångsetiketterna är en funktion av ingångarna.

vi kan skapa ett syntetiskt klassificeringsdataset med flera etiketter med hjälp av make_multilabel_classification () – funktionen i scikit-learn-biblioteket.

vår dataset kommer att ha 1000 prover med 10 inmatningsfunktioner. Datauppsättningen kommer att ha tre klassetikettutgångar för varje prov och varje klass kommer att ha ett eller två värden (0 eller 1, t.ex. närvarande eller inte närvarande).

det fullständiga exemplet på att skapa och sammanfatta den syntetiska Multi-label klassificering dataset listas nedan.

1
2
3
4
5
6
7
8
9

# exempel på en klassificeringsuppgift med flera etiketter
från sklearn.dataset import make_multilabel_classification
# definiera dataset
x, y = make_multilabel_classification (n_samples=1000, n_features=10, n_classes = 3, n_labels = 2, random_state=1)
# sammanfatta dataset form
Skriv ut (X. form, och.form)
# sammanfatta de första exemplen
för i inom räckhåll(10):
Skriv ut (X, y)

att köra exemplet skapar datauppsättningen och sammanfattar formen på inmatnings-och utmatningselementen.

vi kan se att det som förväntat finns 1 000 prover, var och en med 10 ingångsfunktioner och tre utgångsfunktioner.

de första 10 raderna av ingångar och utgångar sammanfattas och vi kan se att alla ingångar för denna dataset är numeriska och att utgångsklassetiketter har 0 eller 1 värden för var och en av de tre klassetiketterna.

1
2
3
4
5
6
7
8
9
10
11
12

(1000, 10) (1000, 3)

Låt oss sedan titta på hur vi kan utveckla neurala nätverksmodeller för klassificeringsuppgifter med flera etiketter.

neurala nätverk för flera etiketter

vissa maskininlärningsalgoritmer stöder klassificering med flera etiketter.

neurala nätverksmodeller kan konfigureras för att stödja klassificering med flera etiketter och kan fungera bra, beroende på detaljerna i klassificeringsuppgiften.

Multi-label-klassificering kan stödjas direkt av neurala nätverk genom att helt enkelt ange antalet måletiketter som finns i problemet som antalet noder i utgångsskiktet. Till exempel kräver en uppgift som har tre utgångsetiketter (klasser) ett neuralt nätverksutgångslager med tre noder i utgångsskiktet.

varje nod i utgångsskiktet måste använda sigmoidaktiveringen. Detta kommer att förutsäga en sannolikhet för klassmedlemskap för etiketten, ett värde mellan 0 och 1. Slutligen måste modellen passa med den binära korsentropiförlustfunktionen.

Sammanfattningsvis, för att konfigurera en neuralnätverksmodell för klassificering med flera etiketter, är detaljerna:

  • antal noder i utgångsskiktet matchar antalet etiketter.
  • sigmoid aktivering för varje nod i utgångsskiktet.
  • binär korsentropi förlust funktion.

vi kan demonstrera detta med hjälp av keras deep learning library.

vi kommer att definiera en Multilayer Perceptron (MLP)-modell för multi-label-klassificeringsuppgiften definierad i föregående avsnitt.

varje prov har 10 ingångar och tre utgångar; därför kräver nätverket ett ingångslager som förväntar sig 10 ingångar som anges via argumentet ”input_dim” i det första dolda lagret och tre noder i utgångsskiktet.

vi kommer att använda den populära Relu-aktiveringsfunktionen i det dolda lagret. Det dolda lagret har 20 noder som valdes efter några försök och fel. Vi kommer att passa modellen med hjälp av binär korsentropiförlust och Adam-versionen av stokastisk gradientnedstigning.

definitionen av nätverket för multi-label-klassificeringsuppgiften anges nedan.

1
2
3
4
5

# definiera modellen
modell = Sekventiell()
modell.Lägg till (tät (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.Lägg till(tät (n_outputs, aktivering=’sigmoid’))
modell.kompilera (förlust= ’binary_crossentropy’, optimizer= ’adam’)

du kanske vill anpassa den här modellen för din egen klassificeringsuppgift med flera etiketter; därför kan vi skapa en funktion för att definiera och returnera modellen där antalet inmatnings-och utgångsvariabler tillhandahålls som argument.

1
2
3
4
5
6
7

# hämta modellen
Def get_model (n_inputs, n_outputs):
modell = Sekventiell ()
modell.Lägg till (tät (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.Lägg till(tät (n_outputs, aktivering=’sigmoid’))
modell.kompilera (förlust= ’binary_crossentropy’, optimizer= ’adam’)
returmodell

nu när vi är bekanta med hur man definierar en MLP för multi-label klassificering, låt oss undersöka hur denna modell kan utvärderas.

neuralt nätverk för klassificering med flera etiketter

om datasetet är litet är det bra att utvärdera neurala nätverksmodeller upprepade gånger på samma dataset och rapportera medelprestanda över upprepningarna.

detta beror på den stokastiska karaktären hos inlärningsalgoritmen.

dessutom är det bra att använda K-faldig korsvalidering istället för tåg / testuppdelningar av en dataset för att få en objektiv uppskattning av modellprestanda när man gör förutsägelser om nya data. Återigen, bara om det inte finns för mycket data att processen kan slutföras inom rimlig tid.

med hänsyn till detta kommer vi att utvärdera MLP-modellen på multi-output regressionsuppgiften med upprepad k-faldig korsvalidering med 10 veck och tre upprepningar.

MLP-modellen förutsäger sannolikheten för varje klassetikett som standard. Detta innebär att det kommer att förutsäga tre sannolikheter för varje prov. Dessa kan konverteras till skarpa klassetiketter genom att avrunda värdena till antingen 0 eller 1. Vi kan sedan beräkna klassificeringsnoggrannheten för de skarpa klassetiketterna.

1
2
3
4
5
6
7

# gör en förutsägelse på testuppsättningen
yhat = modell.förutsäga (X_test)
# runda sannolikheter till klassetiketter
yhat = yhat.runda ()
# beräkna noggrannhet
acc = accuracy_score (y_test, yhat)

poängen samlas in och kan sammanfattas genom att rapportera medel-och standardavvikelsen över alla upprepningar och korsvalideringsveck.

funktionen evaluate_model () nedan tar datauppsättningen, utvärderar modellen och returnerar en lista med utvärderingsresultat, i detta fall noggrannhetspoäng.

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

# utvärdera en modell med upprepad k-faldig korsvalidering
def evaluate_model (X, y):
resultat = lista()
n_inputs, n_outputs= X. form, Y. form
# definiera utvärderingsförfarande
cv = RepeatedKFold (n_splits=10, n_repeats = 3, random_state=1)
# räkna upp veck
för train_ix, test_ix i cv.dela (X):
# Förbered data
x_train, X_test = X, X
y_train, y_test = y, y
# definiera modell
modell = get_model(n_inputs, n_outputs)
# fit modell
modell.passa (X_train, y_train,verbose = 0, epoker=100)
# gör en förutsägelse på testuppsättningen
yhat = modell.förutsäga (X_test)
# runda sannolikheter till klassetiketter
yhat = yhat.runda ()
# beräkna noggrannhet
acc = accuracy_score (y_test, yhat)
# lagra resultat
Skriv ut (’>%.3F ’ % acc)
resultat.Lägg till (acc)
returresultat

vi kan sedan ladda vår dataset och utvärdera modellen och rapportera genomsnittlig prestanda.

binda detta tillsammans, det fullständiga exemplet listas nedan.

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 för multi-label klassificering
från numpy import medelvärde
från numpy import std
från sklearn.dataset importerar make_multilabel_classification
från sklearn.model_selection import RepeatedKFold
från keras.modeller importerar Sekventiell
från keras.lager importerar tät
från sklearn.statistik import accuracy_score
# hämta dataset
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
# hämta modellen
def get_model(n_inputs, n_outputs):
modell = Sekventiell()
modell.Lägg till (tät (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.Lägg till(tät (n_outputs, aktivering=’sigmoid’))
modell.kompilera (förlust=’binary_crossentropy’, optimizer=’adam’)
returmodell
# utvärdera en modell med upprepad k-faldig korsvalidering
def evaluate_model(X, y):
resultat = lista()
n_inputs, n_outputs = X. form, y.form
# definiera utvärderingsförfarande
cv = RepeatedKFold (n_splits=10, n_repeats = 3, random_state=1)
# räkna upp veck
för train_ix, test_ix i cv.dela (X):
# Förbered data
x_train, X_test = X, X
y_train, y_test = y, y
# definiera modell
modell = get_model(n_inputs, n_outputs)
# fit modell
modell.passa (X_train, y_train,verbose = 0, epoker=100)
# gör en förutsägelse på testuppsättningen
yhat = modell.förutsäga (X_test)
# runda sannolikheter till klassetiketter
yhat = yhat.runda ()
# beräkna noggrannhet
acc = accuracy_score (y_test, yhat)
# lagra resultat
Skriv ut (’>%.3F ’ % acc)
resultat.Lägg till(acc)
returnera resultat
# ladda dataset
x, y = get_dataset()
# utvärdera modell
resultat = evaluate_model(X, y)
# sammanfatta prestanda
Skriv ut(’noggrannhet: %.3f (%.3f) ’ % (medelvärde (resultat), std (resultat)))

att köra exemplet rapporterar klassificeringsnoggrannheten för varje veck och varje upprepning, för att ge en uppfattning om utvärderingsförloppet.

notera: dina resultat kan variera med tanke på algoritmens eller utvärderingsprocedurens stokastiska karaktär eller skillnader i numerisk precision. Överväg att köra exemplet några gånger och jämföra det genomsnittliga resultatet.

i slutet rapporteras medel-och standardavvikelsens noggrannhet. I detta fall visas modellen för att uppnå en noggrannhet på cirka 81,2 procent.

du kan använda den här koden som en mall för att utvärdera MLP-modeller på dina egna klassificeringsuppgifter med flera etiketter. Antalet noder och lager i modellen kan enkelt anpassas och anpassas till komplexiteten i din dataset.

1
2
3
4
5
6
7

>0.780
>0.820
>0.790
>0.810
>0.840
noggrannhet: 0.812 (0.032)

när en modellkonfiguration har valts kan vi använda den för att passa en slutlig modell på all tillgänglig data och göra en förutsägelse för nya data.

exemplet nedan visar detta genom att först montera MLP-modellen på hela Multi-label-klassificeringsdatasetet och sedan anropa predict () – funktionen på den sparade modellen för att göra en förutsägelse för en ny rad data.

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

# använd mlp för förutsägelse på multi-label klassificering
från numpy import asarray
från sklearn.dataset importerar make_multilabel_classification
från keras.modeller importerar Sekventiell
från keras.lager importera tät
# hämta dataset
Def get_dataset():
x, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
returnera X, Y
# hämta modellen
def get_model(n_inputs, n_outputs):
modell = Sekventiell()
modell.Lägg till (tät (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, aktivering=’relu’))
modell.Lägg till(tät (n_outputs, aktivering=’sigmoid’))
modell.kompilera (förlust=’ binary_crossentropy’, optimizer=’ adam’)
returmodell
# ladda dataset
x, y = get_dataset()
n_inputs, n_outputs = X. shape, y.shape
# get model
model = get_model(n_inputs, n_outputs)
# montera modellen på alla data
modell.passa (X, y,verbose = 0, epoker=100)
# gör en förutsägelse för nya data
rad =
newX = asarray()
yhat = modell.predict (newX)
print (’Predicted: % s’ % yhat)

att köra exemplet passar modellen och gör en förutsägelse för en ny rad. Som förväntat innehåller förutsägelsen tre utdatavariabler som krävs för klassificeringsuppgiften för flera etiketter: sannolikheten för varje klassetikett.

1
förutsagt:

Vidare läsning

det här avsnittet ger mer resurser om ämnet om du vill gå djupare.

  • klassificering med flera etiketter, Wikipedia.
  • sklearn.datauppsättning.make_multilabel_classification API.
  • Keras hemsida.
  • sklearn.model_selection.RepeatedStratifiedKFold API.

sammanfattning

i denna handledning upptäckte du hur man utvecklar djupa inlärningsmodeller för klassificering med flera etiketter.

specifikt lärde du dig:

  • Multi-label klassificering är en prediktiv modellering uppgift som innebär att förutsäga noll eller flera ömsesidigt icke-exklusiva klassetiketter.
  • neurala nätverksmodeller kan konfigureras för klassificeringsuppgifter med flera etiketter.
  • hur man utvärderar ett neuralt nätverk för klassificering med flera etiketter och gör en förutsägelse för nya data.

har du några frågor?
Ställ dina frågor i kommentarerna nedan och jag kommer att göra mitt bästa för att svara.

utveckla djupa Inlärningsprojekt med Python!

djupinlärning med Python

vad händer om du kan utveckla ett nätverk på några minuter

…med bara några rader Python

Upptäck hur i min nya Ebook:
Deep Learning med Python

det täcker end-to-end-projekt om ämnen som:
Multilayer Perceptrons, Convolutional Nets och Recurrent Neural Net, och mer…

slutligen ta djupt lärande till
dina egna projekt

hoppa över akademikerna. Bara Resultat.

se vad som finns inuti

Tweet Dela Dela



+