Multi-Label Classification with Deep Learning

By admin

Tweet Share Share

laatst bijgewerkt op 31 augustus 2020

multi-label classification omvat het voorspellen van nul of meer klassenlabels.

in tegenstelling tot normale classificatietaken waarbij klasselabels elkaar uitsluiten, vereist multi-label classificatie gespecialiseerde machine learning-algoritmen die het voorspellen van meerdere onderling niet-exclusieve klassen of “labels” ondersteunen.”

Deep learning neural networks zijn een voorbeeld van een algoritme dat van nature problemen met classificatie met meerdere labels ondersteunt. Neurale netwerkmodellen voor multi-label classificatietaken kunnen gemakkelijk worden gedefinieerd en geëvalueerd met behulp van de keras deep learning bibliotheek.

in deze handleiding zult u ontdekken hoe u deep learning modellen voor multi-label classificatie kunt ontwikkelen.

na het voltooien van deze tutorial, zult u weten:

  • Multi-label classificatie is een voorspellende modelleringstaak waarbij nul of meer onderling niet-exclusieve klasselabels worden voorspeld.
  • neurale netwerkmodellen kunnen worden geconfigureerd voor classificatietaken met meerdere labels.
  • hoe een neuraal netwerk te evalueren voor multi-label classificatie en een voorspelling te maken voor nieuwe gegevens.

laten we beginnen.

classificatie met meerdere labels met Deep Learning

classificatie met meerdere labels met Deep Learning
foto door Trevor Marron, enkele rechten voorbehouden.

overzicht Tutorial

deze tutorial bestaat uit drie delen; :

  • multi-Label Classification
  • neurale netwerken voor meerdere Labels
  • neurale netwerken voor multi-Label Classification

Multi-Label Classification

Classification is een voorspellend modelleringsprobleem waarbij een klassenlabel wordt uitgevoerd gegeven enige input

het verschilt van regressietaken waarbij een numerieke waarde wordt voorspeld.

een classificatietaak omvat doorgaans het voorspellen van een enkel label. Afwisselend kan het gaan om het voorspellen van de waarschijnlijkheid over twee of meer klassenlabels. In deze gevallen sluiten de klassen elkaar uit, wat betekent dat de classificatietaak ervan uitgaat dat de invoer slechts tot één klasse behoort.

sommige classificatietaken vereisen het voorspellen van meer dan één klassenetiket. Dit betekent dat klasselabels of klasselidmaatschap elkaar niet uitsluiten. Deze taken worden aangeduid als multiple label classification, of multi-label classification in het kort.

In multi-label classificatie zijn nul of meer labels vereist als output voor elke inputsteekproef en zijn de outputs tegelijkertijd vereist. De aanname is dat de outputlabels een functie zijn van de ingangen.

we kunnen een synthetische multi-label classificatie dataset maken met behulp van de functie make_multilabel_classification () in de sikit-learn bibliotheek.

onze dataset heeft 1.000 samples met 10 invoerfuncties. De dataset heeft drie klassenlabel-uitgangen voor elk monster en elke klasse heeft één of twee waarden (0 of 1, bijvoorbeeld aanwezig of niet aanwezig).

het volledige voorbeeld van het maken en samenvatten van de synthetische multi-label classificatiedataset wordt hieronder weergegeven.

1
2
3
4
5
6
7
8
9
# voorbeeld van een multi-label classificatie taak
van sklearn.datasets importeren make_multilabel_classificatie
# definieer dataset
X, y = make_multilabel_classificatie(n_samples=1000, n_features=10, n_classes=3, n_labels = 2, random_state=1)
# vat de vorm van de gegevensset
samen print (X. vorm, y.vorm)
# vat de eerste voorbeelden samen
voor i in bereik(10):
afdrukken (X, y)

het uitvoeren van het voorbeeld maakt de dataset en vat de vorm van de invoer-en uitvoerelementen samen.

we kunnen zien dat er, zoals verwacht, 1.000 samples zijn, elk met 10 input features en drie output features.

de eerste 10 rijen van ingangen en uitgangen worden samengevat en we kunnen zien dat alle ingangen voor deze dataset numeriek zijn en dat outputklassetiketten 0 of 1 waarden hebben voor elk van de drie klassenetiketten.

1
2
3
4
5
6
7
8
9
10
11
12
(1000, 10) (1000, 3)

laten we Vervolgens kijken hoe kunnen we de ontwikkeling van het neurale netwerk modellen voor multi-label classificatie taken.

neurale netwerken voor meerdere Labels

sommige machine learning algoritmen ondersteunen de classificatie van meerdere labels.

neurale netwerkmodellen kunnen worden geconfigureerd om multi-label classificatie te ondersteunen en kunnen goed presteren, afhankelijk van de specifieke kenmerken van de classificatietaak.

multi-label classificatie kan direct worden ondersteund door neurale netwerken door simpelweg het aantal doellabels in het probleem op te geven als het aantal knooppunten in de uitvoerlaag. Voor een taak met drie uitvoerlabels (klassen) is bijvoorbeeld een neurale netwerkuitvoerlaag nodig met drie knooppunten in de uitvoerlaag.

elk knooppunt in de uitvoerlaag moet de sigmoid-activering gebruiken. Dit voorspelt een kans op class lidmaatschap voor het label, een waarde tussen 0 en 1. Ten slotte moet het model passen bij de binaire cross-entropie loss functie.

om een neuraal netwerkmodel voor multi-label classificatie te configureren, zijn de specifieke kenmerken::

  • het aantal knooppunten in de uitvoerlaag komt overeen met het aantal labels.
  • sigmoid-activering voor elk knooppunt in de uitvoerlaag.
  • binaire cross-entropie verliesfunctie.

we kunnen dit aantonen met behulp van de keras deep learning library.

we zullen een Multilayer Perceptron (MLP) model definiëren voor de multi-label classificatietaak gedefinieerd in de vorige paragraaf.

elk monster heeft 10 ingangen en drie uitgangen; daarom heeft het netwerk een invoerlaag nodig die 10 ingangen verwacht die gespecificeerd zijn via het argument “input_dim” in de eerste Verborgen laag en drie nodes in de uitvoerlaag.

we gebruiken de populaire ReLU-activeringsfunctie in de verborgen laag. De verborgen laag heeft 20 knooppunten die zijn gekozen na een aantal trial and error. We zullen het model passen met behulp van binaire cross-entropie verlies en de Adam versie van stochastische gradiënt afdaling.

de definitie van het netwerk voor de multi-label classificatietaak is hieronder weergegeven.

1
2
3
4
5
# definieer het model
model = Sequential ()
model.toevoegen(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.add(Dense (N_outputs, activation=’sigmoid’))
model.compile(loss= ‘binary_crossentropy’, optimizer= ‘adam’)

misschien wilt u dit model aanpassen voor uw eigen multi-label classificatietaak; daarom kunnen we een functie creëren om het model te definiëren en te retourneren waar het aantal invoer-en uitvoervariabelen als argumenten wordt opgegeven.

1
2
3
4
5
6
7
# het model krijgt
def get_model(n_inputs, n_outputs):
model = Sequentiële()
model.toevoegen(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.add(Dense (N_outputs, activation=’sigmoid’))
model.compile(loss= ‘binary_crossentropy’, optimizer= ‘adam’)
retourmodel

nu we bekend zijn met het definiëren van een MLP voor multi-label classificatie, laten we onderzoeken hoe dit model kan worden geëvalueerd.

neuraal netwerk voor classificatie met meerdere labels

als de dataset klein is, is het een goede praktijk om neurale netwerkmodellen herhaaldelijk op dezelfde dataset te evalueren en de gemiddelde prestaties over de herhalingen te rapporteren.

dit komt door het stochastische karakter van het leeralgoritme.

bovendien is het een goede praktijk om k-voudige kruisvalidatie te gebruiken in plaats van trein/test splitsingen van een dataset om een onbevooroordeelde schatting van modelprestaties te krijgen bij het maken van voorspellingen op nieuwe gegevens. Nogmaals, alleen als er niet te veel gegevens dat het proces kan worden voltooid in een redelijke tijd.

rekening houdend met dit alles, zullen we het MLP-model op de multi-output regressietaak evalueren met behulp van herhaalde K-voudige kruisvalidatie met 10 vouwen en drie herhalingen.

het MLP-model voorspelt standaard de waarschijnlijkheid voor elk klassenetiket. Dit betekent dat het drie waarschijnlijkheden voor elke steekproef zal voorspellen. Deze kunnen worden geconverteerd naar scherpe klassenlabels door de waarden af te ronden naar 0 of 1. Vervolgens kunnen we de classificatienauwkeurigheid voor de crisp class labels berekenen.

1
2
3
4
5
6
7
…
# Maak een voorspelling op de testset
yhat = model.voorspel (X_test)
# rond waarschijnlijkheden voor klassenetiketten
yhat = yhat.round ()
# bereken nauwkeurigheid
acc = accuracy_score (y_test, yhat)

de scores worden verzameld en kunnen worden samengevat door het rapporteren van de gemiddelde en standaardafwijking over alle herhalingen en kruisvalidatievouwen.

de functie evaluate_model () hieronder neemt de dataset, evalueert het model en retourneert een lijst met evaluatiescores, in dit geval nauwkeurigheidsscores.

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
# evalueer een model met herhaalde k-fold cross-validation
def evaluate_model(X, y):
results = list ()
n_inputs, n_outputs = X. vorm, Y. vorm
# definieer evaluatieprocedure
cv = RepeatedKFold (n_splits = 10, n_repeats = 3, random_state=1)
# enumerate folds
voor train_ix, test_ix in cv.split(X):
# prepare data
X_train, X_test = X, X
y_train, y_test = y, y
# define model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit (X_train, y_train,verbose = 0, tijdperken=100)
# Maak een voorspelling op de testset
yhat = model.voorspel (X_test)
# rond waarschijnlijkheden voor klassenetiketten
yhat = yhat.round ()
# calculate accuracy
acc = accuracy_score (y_test, yhat)
# store result
print (‘>%.3f ‘ % acc)
resultaten.append (acc)
retourresultaten

we kunnen dan onze dataset laden en het model evalueren en de gemiddelde prestaties rapporteren.

het volledige voorbeeld wordt hieronder weergegeven.

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 voor multi-label classificatie
van numpy importeren gemiddelde
van numpy importeren std
van sklearn.datasets importeren make_multilabel_classificatie
vanuit sklearn.model_selection Importeer RepeatedKFold
uit keras.modellen importeren sequentieel
uit keras.lagen importeren dicht
vanuit sklearn.gegevens importeren accuracy_score
# voor de dataset
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return X, y
# het model krijgt
def get_model(n_inputs, n_outputs):
model = Sequentiële()
model.toevoegen(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.add(Dense (N_outputs, activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’)
retourmodel
# evalueer een model met herhaalde K-voudige kruisvalidatie
def evaluate_model (X, y):
results = list ()
n_inputs, n_outputs = X. shape, y.vorm
# definieer evaluatieprocedure
cv = RepeatedKFold (n_splits = 10, n_repeats = 3, random_state=1)
# enumerate folds
voor train_ix, test_ix in cv.split(X):
# prepare data
X_train, X_test = X, X
y_train, y_test = y, y
# define model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit (X_train, y_train,verbose = 0, tijdperken=100)
# Maak een voorspelling op de testset
yhat = model.voorspel (X_test)
# rond waarschijnlijkheden voor klassenetiketten
yhat = yhat.round ()
# calculate accuracy
acc = accuracy_score (y_test, yhat)
# store result
print (‘>%.3f ‘ % acc)
resultaten.append (acc)
return results
# load dataset
X, y = get_dataset ()
# evaluate model
results = evaluate_model (X, y)
# summarize performance
print (‘Accuracy: %.3f (%.3f) ‘ % (gemiddelde (resultaten), soa (resultaten))))

het uitvoeren van het voorbeeld rapporteert de classificatienauwkeurigheid voor elke vouw en elke herhaling, om een idee te geven van de voortgang van de evaluatie.

Opmerking: uw resultaten kunnen variëren gezien de stochastische aard van het algoritme of de evaluatieprocedure, of verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.

aan het eind wordt de gemiddelde en standaardafwijking nauwkeurigheid gerapporteerd. In dit geval wordt aangetoond dat het model een nauwkeurigheid van ongeveer 81,2 procent bereikt.

u kunt deze code gebruiken als een sjabloon voor het evalueren van MLP-modellen op uw eigen multi-label classificatietaken. Het aantal knooppunten en lagen in het model kan eenvoudig worden aangepast en aangepast aan de complexiteit van uw dataset.

1
2
3
4
5
6
7
…
>0.780
>0.820
>0.790
>0.810
>0.840
nauwkeurigheid: 0.812 (0.032)

zodra een modelconfiguratie is gekozen, kunnen we deze gebruiken om een definitief model op alle beschikbare gegevens te passen en een voorspelling voor nieuwe gegevens te maken.

het onderstaande voorbeeld demonstreert dit door eerst het MLP-model op de volledige multi-label classificatiedataset te monteren, vervolgens de functie predict() op het opgeslagen model aan te roepen om een voorspelling te maken voor een nieuwe gegevensrij.

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
# gebruik maken van de mlp voor voorspelling op multi-label classificatie
van numpy import asarray
van sklearn.datasets importeren make_multilabel_classificatie
uit keras.modellen importeren sequentieel
uit keras.lagen importeren Dichte
# voor de dataset
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return X, y
# het model krijgt
def get_model(n_inputs, n_outputs):
model = Sequentiële()
model.toevoegen(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.add(Dense (N_outputs, activation=’sigmoid’))
model.compileer(verlies=’binary_crossentropy’, optimizer=’adam’)
model return
# load dataset
X, y = get_dataset()
n_inputs, n_outputs = X. vorm, y.vorm
# krijg een model
model = get_model(n_inputs, n_outputs)
# het model past op alle gegevens
model.fit (X, y, verbose = 0, tijdperken=100)
# Maak een voorspelling voor nieuwe gegevens
row =
newX = asarray ()
yhat = model.predict (newX)
print (‘voorspeld: %s’ % yhat)

het uitvoeren van het voorbeeld past bij het model en maakt een voorspelling voor een nieuwe rij. Zoals verwacht bevat de voorspelling drie uitvoervariabelen die nodig zijn voor de multi-label classificatietaak: de waarschijnlijkheden van elk klassenlabel.

1
voorspeld:

verder lezen

deze sectie biedt meer informatie over het onderwerp als u dieper wilt gaan.

  • multi-label classification, Wikipedia.
  • sklearn.gegevensreeks.make_multilabel_classificatie API.
  • Keras homepage.
  • sklearn.modelselectie.RepeatedStratifiedKFold API.

samenvatting

In deze handleiding ontdekte u hoe u deep learning-modellen kunt ontwikkelen voor classificatie met meerdere labels.

specifiek heb je geleerd:

  • Multi-label classificatie is een voorspellende modelleringstaak waarbij nul of meer onderling niet-exclusieve klasselabels worden voorspeld.
  • neurale netwerkmodellen kunnen worden geconfigureerd voor classificatietaken met meerdere labels.
  • hoe een neuraal netwerk te evalueren voor multi-label classificatie en een voorspelling te maken voor nieuwe gegevens.

heeft u vragen?
Stel uw vragen in de opmerkingen hieronder en Ik zal mijn best doen om te beantwoorden.

ontwikkel Deep Learning projecten met Python!

Deep Learning met Python

wat als u een netwerk zou kunnen ontwikkelen in minuten

…met slechts een paar regels Python

ontdek hoe in mijn nieuwe Ebook:
Deep Learning met Python

het end-to-end projecten behandelt over onderwerpen als:
Meerlagige Perceptrons, convolutionele netten en terugkerende neurale netten, en meer…

breng ten slotte diep leren naar
uw eigen projecten

sla de academici over. Alleen Resultaten.

bekijk wat er in zit

Tweet Share Share

«
»

Related posts

Leave a Comment

Het e-mailadres wordt niet gepubliceerd.

+