Tweet share Podělte
Naposledy Aktualizováno 31. srpna 2020
Multi-label klasifikace zahrnuje předpovídání nula nebo více třídy štítky.
na rozdíl od běžných klasifikačních úloh, kde se štítky tříd vzájemně vylučují, vyžaduje klasifikace více štítků specializované algoritmy strojového učení, které podporují předpovídání více vzájemně nevýhradních tříd nebo „štítků“.“
Hluboké učení neuronové sítě jsou příkladem algoritmu, který nativně podporuje multi-label klasifikace problémy. Modely neuronových sítí pro klasifikační úlohy s více štítky lze snadno definovat a vyhodnotit pomocí knihovny hlubokého učení Keras.
v tomto tutoriálu zjistíte, jak vyvinout modely hlubokého učení pro klasifikaci s více štítky.
Po dokončení tohoto kurzu budete vědět:
- Multi-label klasifikace je prediktivní modelování úkol, který zahrnuje předpovídání nula nebo více vzájemně non-exkluzivní třídy štítky.
- modely neuronových sítí lze konfigurovat pro klasifikační úlohy s více štítky.
- jak vyhodnotit neuronovou síť pro klasifikaci s více štítky a předpovědět nová data.
začněme.
Multi-Label klasifikace s hlubokým učením
Foto Trevor Marron, některá práva vyhrazena.
přehled tutoriálu
tento tutoriál je rozdělen do tří částí; jsou:
- Multi-Label Klasifikace
- Neuronové Sítě pro Více Štítků
- Neuronové Sítě pro Multi-Label Klasifikace
Multi-Label Klasifikace
Klasifikace je prediktivní modelování problému, který zahrnuje výstup třída štítku uvedeny některé vstupní
To je odlišné od regresní úkoly, které se týkají předpovídání číselnou hodnotu.
klasifikační úkol obvykle zahrnuje předpovídání jediného štítku. Alternativně, může to zahrnovat předpovídání pravděpodobnosti na dvou nebo více štítcích tříd. V těchto případech se třídy vzájemně vylučují, což znamená, že klasifikační úkol předpokládá, že vstup patří pouze jedné třídě.
některé klasifikační úlohy vyžadují předpovídání více než jednoho štítku třídy. To znamená, že štítky tříd nebo členství ve třídě se vzájemně nevylučují. Tyto úkoly jsou označovány jako vícenásobná klasifikace štítků nebo zkráceně klasifikace více štítků.
v klasifikaci s více štítky jsou jako výstup pro každý vstupní vzorek vyžadovány nulové nebo více štítků a výstupy jsou vyžadovány současně. Předpokládá se, že výstupní štítky jsou funkcí vstupů.
pomocí funkce make_multilabel_classification() v knihovně scikit-learn můžeme vytvořit syntetický datový soubor s více štítky.
naše datová sada bude mít 1000 vzorků s 10 vstupními funkcemi. Datová sada bude mít tři výstupy štítků třídy pro každý vzorek a každá třída bude mít jednu nebo dvě hodnoty (0 nebo 1, např.
úplný příklad vytvoření a shrnutí syntetického multiznačkového klasifikačního souboru je uveden níže.
|
1
2
3
4
5
6
7
8
9
|
# příklad multi-label klasifikace task
z sklearn.import datových souborů make_multilabel_classification
# define dataset
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
# shrnout dataset tvar
print(X tvar, y.tvar)
# shrnout prvních několik příkladů
for i in range(10):
print(X, y)
|
Běží na příklad vytvoří datový soubor a shrnuje tvar vstupní a výstupní prvky.
vidíme, že podle očekávání existuje 1000 vzorků, z nichž každý má 10 vstupních funkcí a tři výstupní funkce.
prvních 10 řádků vstupy a výstupy jsou shrnuty a můžeme vidět, že všechny vstupy na tomto souboru jsou číselné a že výstup třída štítky mají 0 nebo 1, hodnoty pro každý ze tří třídy štítky.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
(1000, 10) (1000, 3)
|
Další, pojďme se podívat na to, jak můžeme rozvíjet neuronové sítě, modely pro multi-label klasifikace úkolů.
neuronové sítě pro více štítků
některé algoritmy strojového učení podporují nativně klasifikaci více štítků.
modely neuronových sítí mohou být nakonfigurovány tak, aby podporovaly klasifikaci s více štítky a mohou fungovat dobře, v závislosti na specifikách klasifikační úlohy.
multi-label klasifikace může být podporována přímo neuronovými sítěmi jednoduše zadáním počtu cílových štítků je v problému jako počet uzlů ve výstupní vrstvě. Například úloha, která má tři výstupní štítky (třídy), bude vyžadovat výstupní vrstvu neuronové sítě se třemi uzly ve výstupní vrstvě.
každý uzel ve výstupní vrstvě musí používat sigmoidní aktivaci. To bude předpovídat pravděpodobnost členství ve třídě pro štítek, hodnota mezi 0 a 1. Nakonec musí být model přizpůsoben binární funkci ztráty křížové entropie.
stručně řečeno, konfigurace neuronové sítě, model pro multi-label klasifikace, specifika jsou:
- Počet uzlů ve výstupní vrstvě odpovídá počtu štítků.
- sigmoidní aktivace pro každý uzel ve výstupní vrstvě.
- binární křížová entropie ztrátová funkce.
můžeme to prokázat pomocí knihovny hlubokého učení Keras.
definujeme Model vícevrstvého Perceptronu (MLP) pro klasifikační úlohu s více štítky definovanou v předchozí části.
Každý vzorek má 10 vstupů a tři výstupy; proto, že síť vyžaduje vstupní vrstvu, která očekává, že 10 vstupů uvedeno pomocí „input_dim“ argument v první skryté vrstvě a tři uzly ve výstupní vrstvě.
použijeme populární aktivační funkci ReLU ve skryté vrstvě. Skrytá vrstva má 20 uzlů, které byly vybrány po nějakém pokusu a omylu. Do modelu zapadneme pomocí binární křížové entropické ztráty a Adamovy verze stochastického gradientního sestupu.
definice sítě pro klasifikační úlohu s více štítky je uvedena níže.
|
1
2
3
4
5
|
# definovat model
model = Sekvenční()
model.add(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform‘, activation=’relu‘))
model.add(Dense (n_outputs, activation=’sigmoid‘))
model.kompilace(ztráta=’binary_crossentropy‘, optimizer=’adam‘)
|
možná Budete chtít přizpůsobit tento model pro své vlastní multi-label klasifikace úkolu; proto můžeme vytvořit funkci definovat a vrátit se k modelu, kde počet vstupních a výstupních proměnných je k dispozici jako argumenty.
|
1
2
3
4
5
6
7
|
# ten model
def get_model(n_inputs, n_outputs):
model = Sekvenční()
model.add(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform‘, activation=’relu‘))
model.add(Dense (n_outputs, activation=’sigmoid‘))
model.kompilace(ztráta=’binary_crossentropy‘, optimizer=’adam‘)
návrat model
|
Nyní jsme obeznámeni s tím, jak definovat MLP pro multi-label klasifikace, pojďme prozkoumat, jak tento model může být hodnocena.
Neuronové Sítě pro Multi-Label Klasifikace
Pokud datový soubor je malý, je vhodné vyhodnotit, neuronové sítě, modely opakovaně na stejný datový soubor a zprávu, průměrný výkon celé opakuje.
je to kvůli stochastické povaze učebního algoritmu.
kromě toho, že je vhodné použít k-fold cross-validace místo vlaku/test rozdělí dataset získat objektivní odhad modelu výkon při vytváření předpovědi na nová data. Opět pouze v případě, že není příliš mnoho údajů, že proces může být dokončen v rozumném čase.
s ohledem na to vyhodnotíme model MLP na regresní úloze s více výstupy pomocí opakované křížové validace k-fold s 10 záhyby a třemi opakováními.
model MLP ve výchozím nastavení předpovídá pravděpodobnost pro každý štítek třídy. To znamená, že bude předpovídat tři pravděpodobnosti pro každý vzorek. Ty lze převést na ostré štítky tříd zaokrouhlením hodnot na 0 nebo 1. Pak můžeme vypočítat přesnost klasifikace pro štítky třídy crisp.
|
1
2
3
4
5
6
7
|
…
# proveďte předpověď na testovací sadě
yhat = model.predict (X_test)
# round probabilities to class labels
yhat = yhat.round()
# vypočítat přesnost
acc = accuracy_score(y_test, že)
|
výsledky jsou shromažďovány a mohou být shrnuty podle hlášení průměr a směrodatná odchylka přes všechny opakuje a cross-validace záhyby.
evaluate_model() funkce níže trvá dataset, hodnotí model, a vrací seznam hodnocení, skóre, v tomto případě, přesnost skóre.
|
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
|
# vyhodnocení modelu s použitím opakovaná k-fold cross-validace
def evaluate_model(X, y):
výsledky = list()
n_inputs, n_outputs = tvar X, y.tvar
# define postup hodnocení
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# výčet záhyby
pro train_ix, test_ix v cv.split(X):
# příprava dat
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, epochy=100)
# proveďte předpověď na testovací sadě
yhat = model.predict (X_test)
# round probabilities to class labels
yhat = yhat.round()
# vypočítat přesnost
acc = accuracy_score(y_test, že)
# uložit výsledek
print(‚>%.3f ‚ % acc)
výsledky.přidat (acc)
výsledky návratu
|
poté můžeme načíst náš datový soubor a vyhodnotit model a nahlásit průměrný výkon.
spojením tohoto dohromady je úplný příklad uveden níže.
|
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 pro multi-label klasifikace
od numpy import
od numpy import std
z sklearn.datové sady import make_multilabel_classification
z sklearn.model_selection import RepeatedKFold
z keras.modely importují sekvenční
z keras.vrstvy importují hustý
z sklearn.metriky importu accuracy_score
# ten 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
# ten model
def get_model(n_inputs, n_outputs):
model = Sekvenční()
model.add(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform‘, activation=’relu‘))
model.add(Dense (n_outputs, activation=’sigmoid‘))
model.kompilace(ztráta=’binary_crossentropy‘, optimizer=’adam‘)
návrat model
# vyhodnocení modelu s použitím opakovaná k-fold cross-validace
def evaluate_model(X, y):
výsledky = list()
n_inputs, n_outputs = tvar X, y.tvar
# define postup hodnocení
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# výčet záhyby
pro train_ix, test_ix v cv.split(X):
# příprava dat
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, epochy=100)
# proveďte předpověď na testovací sadě
yhat = model.predict (X_test)
# round probabilities to class labels
yhat = yhat.round()
# vypočítat přesnost
acc = accuracy_score(y_test, že)
# uložit výsledek
print(‚>%.3f ‚ % acc)
výsledky.append(acc)
vrátí výsledky,
# načtení datové sady
X, y = get_dataset()
# hodnotit model
výsledky = evaluate_model(X, y)
# shrnout výkon
print(‚Přesnost: %.3f (%.3f)‘ % (průměr(výsledky), std(výsledky)))
|
Běží příklad uvádí přesnost klasifikace pro každý záhyb a každé opakování, pro představu hodnocení pokroku.
Poznámka: vaše výsledky se mohou lišit vzhledem k stochastické povaze algoritmu nebo postupu hodnocení nebo rozdílům v numerické přesnosti. Zvažte několikrát spuštění příkladu a porovnejte průměrný výsledek.
na konci je uvedena střední a směrodatná odchylka. V tomto případě je prokázáno, že model dosahuje přesnosti asi 81,2 procenta.
tento kód můžete použít jako šablonu pro hodnocení modelů MLP na vašich vlastních klasifikačních úlohách s více štítky. Počet uzlů a vrstev v modelu lze snadno přizpůsobit a přizpůsobit složitosti vašeho datového souboru.
|
1
2
3
4
5
6
7
|
…
>0.780
>0.820
>0.790
>0.810
>0.840
Přesnost: 0.812 (0.032)
|
jakmile je zvolena konfigurace modelu, můžeme ji použít k přizpůsobení konečného modelu všem dostupným datům a k předpovědi nových dat.
níže uvedený příklad demonstruje tím, že první montáž MLP model na celé multi-label klasifikace datové sady, a pak volá předpovídat() funkce na uložení modelu tak, aby předpovědi pro nový řádek údajů.
|
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
|
# použití mkp pro predikci na multi-label klasifikaci
z numpy import asarray
z sklearn.datové sady import make_multilabel_classification
z keras.modely importují sekvenční
z keras.vrstvy importovat Husté
# ten 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
# ten model
def get_model(n_inputs, n_outputs):
model = Sekvenční()
model.add(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform‘, activation=’relu‘))
model.add(Dense (n_outputs, activation=’sigmoid‘))
model.kompilace(ztráta=’binary_crossentropy‘, optimizer=’adam‘)
návrat model
# načtení datové sady
X, y = get_dataset()
n_inputs, n_outputs = tvar X, y.tvar
# si model
model = get_model(n_inputs, n_outputs)
# fit model na všechna data
model.fit(X, y, verbose=0, epoch=100)
# dělat předpověď pro nová data
řádek =
newX = asarray()
to = model.předvídat(newX)
print(‚Předpověděl: %s‘ % že)
|
spuštění příkladu se hodí na model a dělá předpovědi pro nový řádek. Jak se očekávalo, predikce obsahuje tři výstupní proměnné potřebné pro klasifikační úlohu s více štítky: pravděpodobnosti každého štítku třídy.
|
1
|
Předpověděl:
|
Další Čtení
Tato část poskytuje více prostředků na toto téma, pokud máte zájem jít hlouběji.
- Multi-label classification, Wikipedia.
- sklearn.sad.make_multilabel_classification API.
- domovská stránka Keras.
- sklearn.model_selection.Opakovanéstratifiedkfold API.
shrnutí
v tomto tutoriálu jste objevili, jak vyvinout modely hlubokého učení pro klasifikaci s více štítky.
Konkrétně, jste se naučili:
- Multi-label klasifikace je prediktivní modelování úkol, který zahrnuje předpovídání nula nebo více vzájemně non-exkluzivní třídy štítky.
- modely neuronových sítí lze konfigurovat pro klasifikační úlohy s více štítky.
- jak vyhodnotit neuronovou síť pro klasifikaci s více štítky a předpovědět nová data.
máte nějaké dotazy?
zeptejte se na své otázky v komentářích níže a já se budu snažit odpovědět.
rozvíjejte projekty hlubokého učení s Pythonem!
co kdybyste mohli vytvořit síť během několika minut
…s jen pár řádků v Pythonu
Zjistit, jak můj nový Ebook:
Hluboké Učení S Python
To zahrnuje end-to-end projektů na témata jako:
Multilayer Perceptrons, Konvoluční Sítě a Rekurentní Neuronové Sítě, a další…
konečně přinést hluboké učení
své vlastní projekty
přeskočit akademiky. Jen Výsledky.
podívejte se, co je uvnitř
Tweet Sdílet Sdílet
