Multi-Label klassificering med dyb læring

kvidre Share Share

sidst opdateret den 31.August 2020

multi-label klassificering involverer forudsigelse af nul eller flere klassemærkater.

i modsætning til normale klassificeringsopgaver, hvor klasseetiketter udelukker hinanden, kræver multi-label-klassificering specialiserede maskinlæringsalgoritmer, der understøtter forudsigelse af flere gensidigt ikke-eksklusive klasser eller “etiketter.”

Deep learning neurale netværk er et eksempel på en algoritme, der indbygget understøtter multi-label klassificeringsproblemer. Neurale netværksmodeller til multi-label klassificeringsopgaver kan let defineres og evalueres ved hjælp af Keras deep learning library.

i denne tutorial vil du opdage, hvordan du udvikler dybe læringsmodeller til klassificering af flere mærker.

efter at have afsluttet denne tutorial, vil du vide:

  • multi-label klassificering er en forudsigelig modelleringsopgave, der involverer forudsigelse af nul eller flere gensidigt ikke-eksklusive klassemærker.
  • neurale netværksmodeller kan konfigureres til multi-label klassificeringsopgaver.
  • sådan evalueres et neuralt netværk til klassificering af flere mærker og forudsiges for nye data.

lad os komme i gang.

Multi-Label klassificering med dyb læring

Multi-Label klassificering med dyb læring
foto af Trevor Marron, nogle rettigheder forbeholdes.

Tutorial Oversigt

denne tutorial er opdelt i tre dele; de er:

  • Multi-Label klassificering
  • neurale netværk til flere Labels
  • neuralt netværk til multi-Label klassificering

Multi-Label klassificering

klassificering er et forudsigeligt modelleringsproblem, der involverer udgivelse af en klassemærke givet noget input

det adskiller sig fra regressionsopgaver, der involverer klassificering af flere Labels

typisk involverer en klassificeringsopgave forudsigelse af en enkelt etiket. Alternativt kan det indebære at forudsige sandsynligheden på tværs af to eller flere klassemærker. I disse tilfælde udelukker klasserne hinanden, hvilket betyder, at klassificeringsopgaven antager, at input kun tilhører en klasse.

nogle klassificeringsopgaver kræver forudsigelse af mere end en klasseetiket. Dette betyder, at klassemærker eller klassemedlemskab ikke udelukker hinanden. Disse opgaver kaldes kort klassificering af flere mærker eller klassificering af flere mærker.

i klassificering med flere etiketter kræves nul eller flere etiketter som output for hver inputprøve, og udgangene kræves samtidigt. Antagelsen er, at outputetiketterne er en funktion af indgangene.

vi kan oprette et syntetisk multi-label klassificeringsdatasæt ved hjælp af make_multilabel_classification ()-funktionen i scikit-learn-biblioteket.

vores datasæt vil have 1.000 prøver med 10 input funktioner. Datasættet har tre klassemærkeudgange for hver prøve, og hver klasse har en eller to værdier (0 eller 1, f.eks. til stede eller ikke til stede).

det komplette eksempel på oprettelse og opsummering af det syntetiske multi-label klassificeringsdatasæt er angivet nedenfor.

1
2
3
4
5
6
7
8
9

# eksempel på en multi-label klassificeringsopgave
fra sklearn.datasæt import make_multilabel_classification
# Definer datasæt
s, y = make_multilabel_classification (n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
# sammendrag datasæt form
Udskriv.form)
# opsummer de første par eksempler
for i inden for rækkevidde(10):
Udskriv)

kørsel af eksemplet opretter datasættet og opsummerer formen på input-og outputelementerne.

vi kan se, at der som forventet er 1.000 prøver, hver med 10 inputfunktioner og tre outputfunktioner.

de første 10 rækker af input og output er opsummeret, og vi kan se, at alle input til dette datasæt er numeriske, og at outputklasseetiketter har 0 eller 1 Værdier for hver af de tre klasseetiketter.

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

(1000, 10) (1000, 3)

lad os derefter se på, hvordan vi kan udvikle neurale netværksmodeller til multi-label klassificeringsopgaver.

neurale netværk til flere etiketter

nogle maskinlæringsalgoritmer understøtter klassificering med flere mærker.

neurale netværksmodeller kan konfigureres til at understøtte klassificering med flere mærker og kan fungere godt afhængigt af klassificeringsopgavens SPECIFIKATIONER.

multi-label klassificering kan understøttes direkte af neurale netværk ved blot at angive antallet af måletiketter, der er i problemet som antallet af noder i outputlaget. For eksempel vil en opgave, der har tre outputetiketter (klasser), kræve et neuralt netværksudgangslag med tre noder i outputlaget.

hver node i outputlaget skal bruge sigmoid-aktiveringen. Dette vil forudsige en sandsynlighed for klassemedlemskab for etiketten, en værdi mellem 0 og 1. Endelig skal modellen være i form med den binære Cross-entropi-tabsfunktion.

Sammenfattende er specifikationerne for at konfigurere en neural netværksmodel til klassificering med flere mærker:

  • antal noder i outputlaget svarer til antallet af etiketter.
  • Sigmoid aktivering for hver node i outputlaget.
  • binær Cross-entropi Tab funktion.

vi kan demonstrere dette ved hjælp af Keras deep learning library.

vi definerer en flerlags Perceptron (MLP) model til multi-label klassificeringsopgaven defineret i det foregående afsnit.

hver prøve har 10 indgange og tre udgange; derfor kræver netværket et inputlag, der forventer 10 indgange specificeret via argumentet “input_dim” i det første skjulte lag og tre noder i outputlaget.

vi bruger den populære ReLU-aktiveringsfunktion i det skjulte lag. Det skjulte lag har 20 noder, der blev valgt efter nogle forsøg og fejl. Vi passer til modellen ved hjælp af binært cross-entropi-tab og Adam-versionen af stokastisk gradientafstamning.

definitionen af netværket til multi-label klassificeringsopgaven er angivet nedenfor.

1
2
3
4
5

# Definer modellen
model = sekventiel ()
model.Tilføj (tæt(20, input_dim=n_inputs, kernel_initialisator= ‘he_uniform’, activation=’ relu’))
model.Tilføj(tæt (n_outputs, activation=’sigmoid’))
model.compile (tab= ‘binary_crossentropy’, optimering= ‘adam’)

du ønsker måske at tilpasse denne model til din egen multi-label klassificeringsopgave; derfor kan vi oprette en funktion til at definere og returnere modellen, hvor antallet af input-og outputvariabler er angivet som argumenter.

1
2
3
4
5
6
7

# Hent modellen
def get_model(n_inputs, n_outputs):
model = sekventiel ()
model.Tilføj (tæt(20, input_dim=n_inputs, kernel_initialisator= ‘he_uniform’, activation=’ relu’))
model.Tilføj(tæt (n_outputs, activation=’sigmoid’))
model.kompilere (tab=’binary_crossentropi’, optimerer=’adam’)
returmodel

nu hvor vi er bekendt med, hvordan man definerer en MLP til klassificering af flere mærker, lad os undersøge, hvordan denne model kan evalueres.

neuralt netværk til klassificering med flere mærker

hvis datasættet er lille, er det god praksis at evaluere neurale netværksmodeller gentagne gange på det samme datasæt og rapportere den gennemsnitlige ydelse på tværs af gentagelserne.

dette skyldes den stokastiske karakter af læringsalgoritmen.

derudover er det god praksis at bruge K-fold krydsvalidering i stedet for tog/testopdelinger af et datasæt for at få et upartisk skøn over modelydelsen, når man forudsiger nye data. Igen, kun hvis der ikke er for mange data, at processen kan afsluttes inden for en rimelig tid.

under hensyntagen til dette vil vi evaluere MLP-modellen på multi-output regressionsopgaven ved hjælp af gentagen k-fold krydsvalidering med 10 folder og tre gentagelser.

MLP-modellen forudsiger som standard sandsynligheden for hver klasseetiket. Dette betyder, at det vil forudsige tre sandsynligheder for hver prøve. Disse kan konverteres til skarpe klassemærker ved at afrunde værdierne til enten 0 eller 1. Vi kan derefter beregne klassificeringsnøjagtigheden for de sprøde klassemærker.

1
2
3
4
5
6
7

# lav en forudsigelse på testsættet
yhat = model.4585 >

# runde sandsynligheder til klasse etiketter
yhat = yhat.runde ()
# Beregn nøjagtighed
acc = accuracy_score(y_test, yhat)

scorerne indsamles og kan opsummeres ved at rapportere middel-og standardafvigelsen på tværs af alle gentagelser og krydsvalideringsfoldninger.

funktionen evaluate_model () nedenfor tager datasættet, evaluerer modellen og returnerer en liste over evalueringsresultater, i dette tilfælde nøjagtighedsscore.

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 model ved hjælp af gentagen k-fold krydsvalidering
def evaluate_model:
resultater = liste ()
n_inputs, n_outputs = form, y.form
# Definer evalueringsprocedure
cv = Gentagetfold (n_splits=10, n_repeats=3, random_state=1)
# opregne folder
for train_iks, test_iks i cv.
# forbered data
y_train, y_test = y, y
# Definer model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit (Y_train, y_train, verbose=0, epoker=100)
# lav en forudsigelse på testsættet
yhat = model.4585 >

# runde sandsynligheder til klasse etiketter
yhat = yhat.runde ()
# Beregn nøjagtighed
acc = accuracy_score (y_test, yhat)
# store resultat
print (‘>%.3F ‘ % acc)
resultater.Tilføj (acc)
retur resultater

vi kan derefter indlæse vores datasæt og evaluere modellen og rapportere den gennemsnitlige ydelse.

ved at binde dette sammen er det komplette eksempel angivet 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 klassificering
fra numpy import middelværdi
fra numpy import std
fra sklearn.datasæt import make_multilabel_classification
fra sklearn.model_selection import Gentagetfold
fra keras.modeller importerer sekventiel
fra keras.lag importerer tæt
fra sklearn.metrics import accuracy_score
# Hent datasættet
def get_dataset():
H, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return, y
# Hent modellen
def get_model(n_inputs, n_outputs):
model = sekventiel()
model.Tilføj (tæt(20, input_dim=n_inputs, kernel_initialisator= ‘he_uniform’, activation=’ relu’))
model.Tilføj(tæt (n_outputs, activation=’sigmoid’))
model.kompilering(tab=’binary_crossentropy’, optimering=’adam’)
returmodel
# Evaluer en model ved hjælp af gentagen k-fold krydsvalidering
def evaluate_model (H, y):
resultater = liste ()
n_inputs, n_outputs = form, y.form
# Definer evalueringsprocedure
cv = Gentagetfold (n_splits=10, n_repeats=3, random_state=1)
# opregne folder
for train_iks, test_iks i cv.
# forbered data
y_train, y_test = y, y
# Definer model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit (Y_train, y_train, verbose=0, epoker=100)
# lav en forudsigelse på testsættet
yhat = model.4585 >

# runde sandsynligheder til klasse etiketter
yhat = yhat.runde ()
# Beregn nøjagtighed
acc = accuracy_score (y_test, yhat)
# store resultat
print (‘>%.3F ‘ % acc)
resultater.Tilføj(acc)
returresultater
# Indlæs datasæt
h, y = get_dataset()
# Evaluer model
results = evaluate_model(H, y)
# opsummer ydeevne
print(‘nøjagtighed: %.3f (%.3f) ‘ % (gennemsnit (resultater), std (resultater)))

kørsel af eksemplet rapporterer klassificeringsnøjagtigheden for hver fold og hver gentagelse for at give en ide om evalueringsforløbet.

Bemærk: dine resultater kan variere i betragtning af algoritmens eller evalueringsprocedurens stokastiske karakter eller forskelle i numerisk præcision. Overvej at køre eksemplet et par gange, og sammenlign det gennemsnitlige resultat.

i slutningen rapporteres gennemsnits-og standardafvigelsesnøjagtigheden. I dette tilfælde er modellen vist at opnå en nøjagtighed på omkring 81,2 procent.

du kan bruge denne kode som en skabelon til evaluering af MLP-modeller på dine egne multi-label klassificeringsopgaver. Antallet af noder og lag i modellen kan nemt tilpasses og skræddersys til kompleksiteten af dit datasæt.

1
2
3
4
5
6
7

>0.780
>0.820
>0.790
>0.810
>0.840
nøjagtighed: 0.812 (0.032)

når en modelkonfiguration er valgt, kan vi bruge den til at passe til en endelig model på alle tilgængelige data og forudsige nye data.

eksemplet nedenfor viser dette ved først at montere MLP-modellen på hele multi-label klassificeringsdatasættet og derefter kalde funktionen predict() på den gemte model for at forudsige en ny række 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

# brug mlp til forudsigelse på multi-label klassificering
fra numpy import asarray
fra sklearn.datasæt import make_multilabel_classification
fra keras.modeller importerer sekventiel
fra keras.lag import tæt
# Hent datasættet
def get_dataset():
s, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return, y
# Hent modellen
def get_model(n_inputs, n_outputs):
model = sekventiel()
model.Tilføj (tæt(20, input_dim=n_inputs, kernel_initialisator= ‘he_uniform’, activation=’ relu’))
model.Tilføj(tæt (n_outputs, activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimisator=’adam’)
returmodel
# Indlæs datasæt
H, y = get_dataset()
n_inputs, n_outputs = H. form, y.form
# Hent model
model = get_model(n_inputs, n_outputs)
# tilpas modellen på alle data
model.fit (H, y, verbose=0, epoker=100)
# lav en forudsigelse for nye data
række =
ny = asarray ()
yhat = model.
Udskriv (‘forudsagt: % s’ % yhat)

at køre eksemplet passer til modellen og forudsiger en ny række. Som forventet indeholder forudsigelsen tre outputvariabler, der kræves til multi-label-klassificeringsopgaven: sandsynlighederne for hver klassemærke.

1
forudsagt:

yderligere læsning

dette afsnit giver flere ressourcer om emnet, hvis du ønsker at gå dybere.

  • multi-label klassificering.
  • sklearn.datasæt.MAKE_MULTILABEL_CLASSIFICATION API.
  • Keras hjemmeside.
  • sklearn.model_selection.RepeatedStratifiedKFold API.

Resume

i denne tutorial opdagede du, hvordan du udvikler dybe læringsmodeller til klassificering af flere mærker.

specifikt lærte du:

  • multi-label klassificering er en forudsigelig modelleringsopgave, der involverer forudsigelse af nul eller flere gensidigt ikke-eksklusive klassemærker.
  • neurale netværksmodeller kan konfigureres til multi-label klassificeringsopgaver.
  • sådan evalueres et neuralt netværk til klassificering af flere mærker og forudsiges for nye data.

har du nogen spørgsmål?
stil dine spørgsmål i kommentarerne nedenfor, og jeg vil gøre mit bedste for at svare.

udvikle dybe læringsprojekter med Python!

dyb læring med Python

hvad hvis du kunne udvikle et netværk på få minutter

…med blot et par linjer Python

Opdag hvordan i min nye e-bog:
dyb læring med Python

det dækker end-to-end projekter om emner som:
flerlags Perceptroner, Konvolutionsnet og tilbagevendende neurale net og meget mere…

endelig bringe dyb læring til
dine egne projekter

Spring akademikerne over. Bare Resultater.

se hvad der er indeni

bøger fra Share Share



+