Clasificare Multi-Label cu învățare profundă

Tweet Share Share

Ultima actualizare la 31 August 2020

clasificarea Multi-label implică prezicerea etichetelor de clasă zero sau mai multe.

spre deosebire de sarcinile normale de clasificare în care etichetele de clasă se exclud reciproc, clasificarea cu mai multe etichete necesită algoritmi specializați de învățare automată care acceptă prezicerea mai multor clase sau „etichete” neexclusive reciproc.”

rețelele neuronale de învățare profundă sunt un exemplu de algoritm care acceptă nativ probleme de clasificare cu mai multe etichete. Modele de rețele neuronale pentru sarcini de clasificare multi-label pot fi ușor definite și evaluate folosind biblioteca Keras deep learning.

în acest tutorial, veți descoperi cum să dezvoltați modele de învățare profundă pentru clasificarea pe mai multe etichete.

după finalizarea acestui tutorial, veți ști:

clasificarea cu mai multe etichete este o sarcină de modelare predictivă care implică prezicerea etichetelor de clasă zero sau mai neexclusive reciproc.
modelele de rețele neuronale pot fi configurate pentru sarcini de clasificare cu mai multe etichete.
cum se evaluează o rețea neuronală pentru clasificarea pe mai multe etichete și se face o predicție pentru date noi.

să începem.

clasificare Multi-etichetă cu învățare profundă
fotografie de Trevor Marron, unele drepturi rezervate.

tutorial prezentare generală
clasificare Multi-etichetă
rețele neuronale pentru mai multe etichete
rețea neuronală pentru clasificarea pe Mai multe etichete
Lectură suplimentară
rezumat
dezvoltați proiecte de învățare profundă cu Python!
ce se întâmplă dacă ai putea dezvolta o rețea în câteva minute
în cele din urmă aduceți învățarea profundă la propriile proiecte

tutorial prezentare generală

acest tutorial este împărțit în trei părți; acestea sunt:

clasificare Multi-etichetă
rețele neuronale pentru mai multe etichete
rețea neuronală pentru clasificare Multi-etichetă

clasificare Multi-etichetă

clasificarea este o problemă de modelare predictivă care implică ieșirea unei etichete de clasă dată unor intrări

este diferită de sarcinile de regresie aceasta implică prezicerea unei valori numerice.

de obicei, o sarcină de clasificare implică prezicerea unei singure etichete. Alternativ, ar putea implica prezicerea probabilității pe două sau mai multe etichete de clasă. În aceste cazuri, clasele se exclud reciproc, ceea ce înseamnă că sarcina de clasificare presupune că intrarea aparține unei singure clase.

unele sarcini de clasificare necesită prezicerea mai multor etichete de clasă. Aceasta înseamnă că etichetele clasei sau calitatea de membru al clasei nu se exclud reciproc. Aceste sarcini sunt denumite clasificare cu mai multe etichete sau clasificare cu mai multe etichete pe scurt.

în clasificarea cu mai multe etichete, zero sau mai multe etichete sunt necesare ca ieșire pentru fiecare eșantion de intrare, iar ieșirile sunt necesare simultan. Presupunerea este că etichetele de ieșire sunt o funcție a intrărilor.

putem crea un set de date sintetice de clasificare cu mai multe etichete folosind funcția make_multilabel_classification() din biblioteca scikit-learn.

setul nostru de date va avea 1.000 de eșantioane cu 10 caracteristici de intrare. Setul de date va avea trei ieșiri de etichete de clasă pentru fiecare eșantion și fiecare clasă va avea una sau două valori (0 sau 1, de exemplu, prezent sau nu).

exemplul complet de creare și rezumare a setului de date sintetice de clasificare multi-etichetă este prezentat mai jos.

# exemplu de sarcină de clasificare cu mai multe etichete

din sklearn.seturi de date Import make_multilabel_classification

# define set de date

X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes = 3, n_labels = 2, random_state=1)

# rezumați forma setului de date

imprimare(X. shape, y.forma)

# rezuma primele câteva exemple

pentru i în gama(10):

imprimare (X, y)

rularea exemplului creează setul de date și rezumă forma elementelor de intrare și ieșire.

putem vedea că, așa cum era de așteptat, există 1.000 de eșantioane, fiecare cu 10 caracteristici de intrare și trei caracteristici de ieșire.

sunt rezumate primele 10 rânduri de intrări și ieșiri și putem vedea că toate intrările pentru acest set de date sunt numerice și că etichetele clasei de ieșire au valori 0 sau 1 pentru fiecare dintre cele trei etichete de clasă.

(1000, 10) (1000, 3)

în continuare, să ne uităm la modul în care putem dezvolta modele de rețele neuronale pentru sarcini de clasificare cu mai multe etichete.

rețele neuronale pentru mai multe etichete

unii algoritmi de învățare automată acceptă clasificarea multi-etichetă nativ.

modelele de rețele neuronale pot fi configurate pentru a sprijini clasificarea cu mai multe etichete și pot funcționa bine, în funcție de specificul sarcinii de clasificare.

clasificarea multi-label poate fi susținută direct de rețelele neuronale pur și simplu prin specificarea numărului de etichete țintă există în problema ca numărul de noduri în stratul de ieșire. De exemplu, o sarcină care are trei etichete de ieșire (clase) va necesita un strat de ieșire de rețea neuronală cu trei noduri în stratul de ieșire.

fiecare nod din stratul de ieșire trebuie să utilizeze activarea sigmoid. Aceasta va prezice o probabilitate de apartenență la clasă pentru etichetă, o valoare cuprinsă între 0 și 1. În cele din urmă, modelul trebuie să se potrivească cu funcția binară de pierdere a entropiei încrucișate.

în rezumat, pentru a configura un model de rețea neuronală pentru clasificarea cu mai multe etichete, specificul este:

Numărul de noduri din stratul de ieșire se potrivește cu numărul de etichete.
activare Sigmoid pentru fiecare nod din stratul de ieșire.
funcția binară de pierdere a entropiei încrucișate.

putem demonstra acest lucru folosind biblioteca de învățare profundă Keras.

vom defini un model multistrat Perceptron (MLP) pentru sarcina de clasificare multi-label definită în secțiunea anterioară.

fiecare eșantion are 10 intrări și trei ieșiri; prin urmare, rețeaua necesită un strat de intrare care așteaptă 10 intrări specificate prin argumentul „input_dim” în primul strat ascuns și trei noduri în stratul de ieșire.

vom folosi funcția populară de activare ReLU în stratul ascuns. Stratul ascuns are 20 de noduri care au fost alese după unele încercări și erori. Vom potrivi modelul folosind pierderea binară a entropiei încrucișate și versiunea Adam a coborârii gradientului stochastic.

definiția rețelei pentru sarcina de clasificare cu mai multe etichete este prezentată mai jos.

# definiți modelul

model = secvențial ()

model.adăugați(dens (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))

model.adăugați(dens (n_outputs, activation=’sigmoid’))

model.compilare (pierdere = ‘binary_crossentropy’, optimizator = ‘adam’)

poate doriți să adaptați acest model pentru propria sarcină de clasificare multi-label; prin urmare, putem crea o funcție pentru a defini și returna modelul în care numărul de variabile de intrare și ieșire este furnizat ca argumente.

# obțineți modelul

Def get_model(n_inputs, n_outputs):

model = secvențial ()

model.adăugați(dens (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))

model.adăugați(dens (n_outputs, activation=’sigmoid’))

model.compilare (loss = ‘binary_crossentropy’, optimizer = ‘adam’)

model de retur

acum, că suntem familiarizați cu modul de definire a unui MLP pentru clasificarea pe mai multe etichete, să explorăm modul în care acest model poate fi evaluat.

rețea neuronală pentru clasificarea pe Mai multe etichete

dacă setul de date este mic, este o practică bună să evaluați modelele rețelei neuronale în mod repetat pe același set de date și să raportați performanța medie între repetări.

acest lucru se datorează naturii stocastice a algoritmului de învățare.

în plus, este o practică bună să se utilizeze validarea încrucișată k-fold în locul divizărilor tren/test ale unui set de date pentru a obține o estimare imparțială a performanței modelului atunci când se fac predicții cu privire la date noi. Din nou, numai dacă nu există prea multe date, procesul poate fi finalizat într-un timp rezonabil.

luând în considerare acest lucru, vom evalua modelul MLP pe sarcina de regresie multi-ieșire folosind validarea încrucișată k-fold repetată cu 10 pliuri și trei repetări.

modelul MLP va prezice probabilitatea pentru fiecare etichetă de clasă în mod implicit. Aceasta înseamnă că va prezice trei probabilități pentru fiecare eșantion. Acestea pot fi convertite în etichete de clasă clare prin rotunjirea valorilor la 0 sau 1. Putem calcula apoi precizia de clasificare pentru etichetele de clasă clare.

…

# faceți o predicție pe setul de testare

yhat = model.preziceți (X_test)

# probabilități rotunde la etichetele clasei

yhat = yhat.round ()

# calculați precizia

acc = accuracy_score( y_test, yhat)

scorurile sunt colectate și pot fi rezumate prin raportarea abaterii medii și standard pentru toate repetările și faldurile de validare încrucișată.

funcția evaluate_model() de mai jos preia setul de date, evaluează modelul și returnează o listă de scoruri de evaluare, în acest caz, scoruri de precizie.

# evaluați un model utilizând validarea încrucișată k-fold repetată

Def evaluate_model(X, y) :

results = list ()

n_inputs, n_outputs= X. shape, y. shape

# define procedura de evaluare

cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

# enumerați falduri

pentru train_ix, test_ix în cv.split(X):

# pregătiți datele

X_train, X_test = x, x

y_train, y_test = y, y

# definiți modelul

model = get_model(n_inputs, n_outputs)

# fit model

model.fit (X_train, y_train, verbose=0, epoci=100)

# faceți o predicție pe setul de testare

yhat = model.preziceți (X_test)

# probabilități rotunde la etichetele clasei

yhat = yhat.round()

# calculați precizia

acc = accuracy_score(y_test, yhat)

# stocați rezultatul

imprimare(‘>%.3F ‘ % acc)

rezultate.adăugați (acc)

rezultate retur

apoi putem încărca setul nostru de date și putem evalua modelul și raporta performanța medie.

legând acest lucru împreună, exemplul complet este prezentat mai jos.

# mlp pentru clasificarea pe mai multe etichete

de la importul numpy înseamnă

de la importul numpy std

de la sklearn.seturi de date Import make_multilabel_classification

din sklearn.model_selection import RepeatedKFold

din keras.modelele importă secvențial

din keras.straturi de import dens

din sklearn.metrics import accuracy_score

# ia setul de date

Def get_dataset():

X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)

întoarcere x, y

# obțineți modelul

def get_model(n_inputs, n_outputs):

model = secvențial()

model.adăugați(dens (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))

model.adăugați(dens (n_outputs, activation=’sigmoid’))

model.compile (loss=’binary_crossentropy’, optimizer=’adam’)

model de întoarcere

# evaluează un model folosind validare încrucișată repetată de K ori

Def evaluate_model(x, y):

results = list()

n_inputs, n_outputs = X. forma, y.forma

# definiți procedura de evaluare

cv = RepeatedKFold(n_splits = 10, n_repeats=3, random_state=1)

# enumerați falduri

pentru train_ix, test_ix în cv.split(X):

# pregătiți datele

X_train, X_test = x, x

y_train, y_test = y, y

# definiți modelul

model = get_model(n_inputs, n_outputs)

# fit model

model.fit (X_train, y_train, verbose=0, epoci=100)

# faceți o predicție pe setul de testare

yhat = model.preziceți (X_test)

# probabilități rotunde la etichetele clasei

yhat = yhat.round()

# calculați precizia

acc = accuracy_score(y_test, yhat)

# stocați rezultatul

imprimare(‘>%.3F ‘ % acc)

rezultate.append(acc)

returnează rezultate

# set de date de încărcare

X, y = get_dataset()

# evaluează modelul

rezultate = evaluate_model(x, y)

# rezumă performanța

Print(‘precizie: %.3f (%.3f) ‘ % (medie (rezultate), std (rezultate)))

rularea exemplului raportează precizia clasificării pentru fiecare pliere și fiecare repetare, pentru a da o idee despre progresul evaluării.

notă: rezultatele dvs. pot varia în funcție de natura stocastică a algoritmului sau a procedurii de evaluare sau de diferențele de precizie numerică. Luați în considerare rularea exemplului de câteva ori și comparați rezultatul mediu.

la sfârșit, se raportează precizia medie și deviația standard. În acest caz, se arată că modelul obține o precizie de aproximativ 81, 2 la sută.

puteți utiliza acest cod ca șablon pentru evaluarea modelelor MLP pe propriile sarcini de clasificare cu mai multe etichete. Numărul de noduri și straturi din model poate fi ușor adaptat și adaptat la complexitatea setului dvs. de date.

…

>0.780

>0.820

>0.790

>0.810

>0.840

precizie: 0.812 (0.032)

odată aleasă o configurație de model, o putem folosi pentru a se potrivi unui model final pe toate datele disponibile și pentru a face o predicție pentru date noi.

exemplul de mai jos demonstrează acest lucru prin montarea mai întâi a modelului MLP pe întregul set de date de clasificare multi-label, apoi apelând funcția prezicere() pe modelul salvat pentru a face o predicție pentru un nou rând de date.

# utilizați mlp pentru predicție pe clasificarea multi-etichetă

de la numpy import asarray

de la sklearn.seturi de date Import make_multilabel_classification

din keras.modelele importă secvențial

din keras.straturi de import dens

# ia setul de date

Def get_dataset():

X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)

întoarcere X, Y

# obțineți modelul

def get_model(n_inputs, n_outputs):

model = secvențial()

model.adăugați(dens (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))

model.adăugați(dens (n_outputs, activation=’sigmoid’))

model.compile (loss=’ binary_crossentropy’, optimizer = ‘adam’)

model de întoarcere

# set de date de încărcare

X, y = get_dataset()

n_inputs, n_outputs = X. shape, y.shape

# get model

model = get_model(n_inputs, n_outputs)

# se potrivesc modelul pe toate datele

model.fit (X, y, verbose=0, epoci=100)

# faceți o predicție pentru date noi

rând =

newX = asarray ()

yhat = model.prezice (newX)

print (‘prezis: % s’ % yhat)

rularea exemplului se potrivește modelului și face o predicție pentru un rând nou. Așa cum era de așteptat, predicția conține trei variabile de ieșire necesare pentru sarcina de clasificare cu mai multe etichete: probabilitățile fiecărei etichete de clasă.

prezis:

Lectură suplimentară

această secțiune oferă mai multe resurse pe această temă dacă doriți să aprofundați.

clasificare Multi-etichetă, Wikipedia.
sklearn.seturi de date.make_multilabel_classification API.
Keras pagina de start.
sklearn.model_selection.RepeatedStratifiedKFold API.

rezumat

în acest tutorial, ați descoperit cum să dezvoltați modele de învățare profundă pentru clasificarea pe mai multe etichete.

mai exact, ai învățat:

clasificarea cu mai multe etichete este o sarcină de modelare predictivă care implică prezicerea etichetelor de clasă zero sau mai neexclusive reciproc.
modelele de rețele neuronale pot fi configurate pentru sarcini de clasificare cu mai multe etichete.
cum se evaluează o rețea neuronală pentru clasificarea pe mai multe etichete și se face o predicție pentru date noi.

aveți întrebări?
puneți-vă întrebările în comentariile de mai jos și voi face tot posibilul să răspund.