Tweet Share Share
Utoljára frissítve: augusztus 31, 2020
a Multi-label osztályozás magában foglalja a nulla vagy több osztálycímke előrejelzését.
a normál osztályozási feladatoktól eltérően, ahol az osztálycímkék kölcsönösen kizárják egymást, a többcímkés osztályozáshoz speciális gépi tanulási algoritmusokra van szükség, amelyek támogatják a több kölcsönösen nem kizárólagos osztály vagy “címke” előrejelzését.”
a mély tanulási neurális hálózatok egy olyan algoritmus példája, amely natív módon támogatja a többcímkés osztályozási problémákat. A többcímkés osztályozási feladatok neurális hálózati modelljei könnyen meghatározhatók és értékelhetők a Keras deep learning könyvtár segítségével.
ebben az oktatóanyagban megtudhatja, hogyan lehet mély tanulási modelleket fejleszteni a többcímkés osztályozáshoz.
miután befejezte ezt az oktatóanyagot, tudni fogja:
- a többcímkés osztályozás egy prediktív modellezési feladat, amely magában foglalja a nulla vagy több kölcsönösen nem kizárólagos osztálycímke előrejelzését.
- neurális hálózati modellek konfigurálhatók többcímkés osztályozási feladatokhoz.
- hogyan értékeljünk egy neurális hálózatot a többcímkés osztályozáshoz és készítsünk előrejelzést az új adatokra.
kezdjük.
Multi-Label osztályozás mély tanulással
fotó: Trevor Marron, néhány jog fenntartva.
bemutató Áttekintés
ez a bemutató három részre oszlik; ezek:
- többcímkés osztályozás
- neurális hálózatok többcímkés osztályozáshoz
- neurális hálózat többcímkés osztályozáshoz
többcímkés osztályozás
az osztályozás egy prediktív modellezési probléma, amely magában foglalja az osztálycímke kimenetét bizonyos bemenetekkel
ez különbözik a regressziós feladatoktól, amelyek numerikus érték előrejelzése.
az osztályozási feladat általában egyetlen címke előrejelzését foglalja magában. Felváltva, ez magában foglalhatja a valószínűség előrejelzését két vagy több osztálycímkén. Ezekben az esetekben az osztályok kölcsönösen kizárják egymást, vagyis az osztályozási feladat feltételezi, hogy a bemenet csak egy osztályhoz tartozik.
egyes osztályozási feladatok egynél több osztálycímke előrejelzését igénylik. Ez azt jelenti, hogy az osztálycímkék vagy az osztálytagság nem zárják ki egymást. Ezeket a feladatokat több címke osztályozásnak vagy röviden több címke osztályozásnak nevezzük.
a többcímkés osztályozásban nulla vagy több címke szükséges kimenetként minden bemeneti mintához, a kimenetek pedig egyidejűleg szükségesek. A feltételezés az, hogy a kimeneti címkék a bemenetek függvénye.
létrehozhatunk egy szintetikus többcímkés osztályozási adatkészletet a make_multilabel_classification() függvény segítségével a scikit-learn könyvtárban.
adatkészletünk 1000 mintával rendelkezik, 10 bemeneti funkcióval. Az adatkészletnek három osztálycímke kimenete lesz minden mintához, és minden osztálynak egy vagy két értéke lesz (0 vagy 1, pl. jelen vagy nincs jelen).
a szintetikus többcímkés osztályozási adatkészlet létrehozásának és összefoglalásának teljes példája az alábbiakban található.
|
1
2
3
4
5
6
7
8
9
|
# példa többcímkés osztályozási feladatra
a sklearn – tól.adatkészletek importálása make_multilabel_classification
# adatkészlet meghatározása
X, y = make_multilabel_classification (n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
# összegezze az adatkészlet alakját
nyomtatás (X. alak, y.alak)
# összefoglalja az első néhány példát
az I tartományban(10):
nyomtatás (X, y)
|
a példa futtatása létrehozza az adatkészletet, és összefoglalja a bemeneti és kimeneti elemek alakját.
láthatjuk, hogy a várakozásoknak megfelelően 1000 minta van, mindegyik 10 bemeneti funkcióval és három kimeneti funkcióval rendelkezik.
a bemenetek és kimenetek első 10 sorát összegezzük, és láthatjuk, hogy az adatkészlet összes bemenete numerikus, és hogy a kimeneti osztálycímkék mindhárom osztálycímkéhez 0 vagy 1 értéket tartalmaznak.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
(1000, 10) (1000, 3)
|
ezután nézzük meg, hogyan fejleszthetünk neurális hálózati modelleket a többcímkés osztályozási feladatokhoz.
neurális hálózatok több címkéhez
egyes gépi tanulási algoritmusok natív módon támogatják a többcímkés osztályozást.
a neurális hálózati modellek konfigurálhatók a többcímkés osztályozás támogatására, és az osztályozási feladat sajátosságaitól függően jól teljesíthetnek.
a többcímkés osztályozást közvetlenül a neurális hálózatok támogathatják, egyszerűen megadva a problémában lévő célcímkék számát, mint a kimeneti réteg csomópontjainak számát. Például egy olyan feladathoz, amelynek három kimeneti címkéje (osztálya) van, szükség lesz egy neurális hálózati kimeneti rétegre, amelynek három csomópontja van a kimeneti rétegben.
a kimeneti réteg minden csomópontjának a szigmoid aktiválást kell használnia. Ez megjósolja a címke osztálytagságának valószínűségét, 0 és 1 közötti értéket. Végül a modellnek illeszkednie kell a bináris kereszt-entrópia veszteségfüggvényhez.
összefoglalva, a neurális hálózati modell konfigurálásához a többcímkés osztályozáshoz a sajátosságok a következők:
- a kimeneti réteg csomópontjainak száma megegyezik a címkék számával.
- szigmoid aktiválás a kimeneti réteg minden csomópontjához.
- bináris kereszt-entrópia veszteség funkció.
ezt a Keras deep learning könyvtár segítségével tudjuk bemutatni.
meghatározunk egy többrétegű Perceptron (MLP) modellt az előző szakaszban meghatározott többcímkés osztályozási feladathoz.
minden minta 10 bemenettel és három kimenettel rendelkezik; ezért a hálózatnak szüksége van egy bemeneti rétegre, amely 10 bemenetet vár el az “input_dim” argumentumon keresztül az első rejtett rétegben, és három csomópontot a kimeneti rétegben.
a népszerű ReLU aktiválási funkciót fogjuk használni a rejtett rétegben. A rejtett rétegnek 20 csomópontja van, amelyeket néhány próba után választottak ki. A modellt bináris kereszt-entrópia veszteséggel és a sztochasztikus gradiens Süllyedés Adam változatával illesztjük be.
az alábbiakban felsoroljuk a többcímkés osztályozási feladat hálózatának meghatározását.
|
1
2
3
4
5
|
# adja meg a
model = Sequential()
model modellt.add (sűrű(20, input_dim=n_inputs, kernel_initializer= ‘he_uniform’, activation= ‘relu’))
modell.add (sűrű(n_outputs, activation= ‘sigmoid’))
modell.compile (loss= ‘binary_crossentropy’, optimizer= ‘adam’)
|
érdemes lehet adaptálni ezt a modellt a saját többcímkés osztályozási feladatához; ezért létrehozhatunk egy függvényt a modell definiálására és visszaadására, ahol a bemeneti és kimeneti változók száma argumentumként van megadva.
|
1
2
3
4
5
6
7
|
# szerezd meg a modellt
def get_model(n_inputs, n_outputs):
model = Sequential()
model.add (sűrű(20, input_dim=n_inputs, kernel_initializer= ‘he_uniform’, activation= ‘relu’))
modell.add (sűrű(n_outputs, activation= ‘sigmoid’))
modell.compile (loss=’binary_crossentropy’, optimizer=’adam’)
visszatérési modell
|
most, hogy ismerjük az MLP meghatározását a többcímkés osztályozáshoz, vizsgáljuk meg, hogyan értékelhető ez a modell.
neurális hálózat többcímkés osztályozáshoz
ha az adatkészlet kicsi, jó gyakorlat, ha ugyanazon az adatkészleten ismételten értékelik a neurális hálózati modelleket, és az ismétlések átlagos teljesítményét jelentik.
ennek oka a tanulási algoritmus sztochasztikus jellege.
ezenkívül jó gyakorlat a K-szeres keresztellenőrzés használata az adatkészlet vonat/teszt felosztása helyett, hogy elfogulatlan becslést kapjon a modell teljesítményéről az új adatokra vonatkozó előrejelzések készítésekor. Ismét csak akkor, ha nincs túl sok adat, hogy a folyamat ésszerű időn belül befejezhető.
ezt figyelembe véve értékeljük az MLP modellt a multi-output regressziós feladaton ismételt k-szeres keresztellenőrzéssel, 10 hajtással és három ismétléssel.
az MLP modell alapértelmezés szerint megjósolja az egyes osztálycímkék valószínűségét. Ez azt jelenti, hogy minden mintára három valószínűséget fog megjósolni. Ezek éles osztálycímkékké alakíthatók, ha az értékeket 0-ra vagy 1-re kerekítik. Ezután kiszámíthatjuk az éles osztálycímkék osztályozási pontosságát.
|
1
2
3
4
5
6
7
|
…
# készítsen előrejelzést a tesztkészleten
yhat = modell.predict (X_test)
# kerek valószínűségek osztálycímkékhez
yhat = yhat.kerek ()
# pontosság kiszámítása
acc = accuracy_score (y_test, yhat)
|
a pontszámok összegyűjtése és összefoglalása az átlag és a szórás jelentésével történik az összes ismétlésben és keresztellenőrzési hajtásban.
az alábbi evaluate_model() függvény veszi az adatkészletet, kiértékeli a modellt, és visszaadja az értékelési pontszámok listáját, ebben az esetben a pontossági pontszámokat.
|
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
|
# modell értékelése ismételt k-szeres keresztellenőrzéssel
def evaluate_model (X, y):
eredmények = lista()
n_inputs, n_outputs = X. alak, y.alak
# értékelési eljárás meghatározása
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# sorolja fel a
hajtásokat a train_ix, test_ix cv-ben.split(x):
# adatok előkészítése
x_train, X_test = X, X
y_train, y_test = y, y
# modell meghatározása
model = get_model(n_inputs, n_outputs)
# fit modell
modell.fit (X_train, y_train, bőbeszédű=0, korszakok=100)
# készítsen előrejelzést a tesztkészleten
yhat = modell.predict (X_test)
# kerek valószínűségek osztálycímkékhez
yhat = yhat.kerek ()
# a pontosság kiszámítása
acc = accuracy_score (y_test, yhat)
# az eredmény tárolása
nyomtatás (‘>%.3f ‘ % acc)
eredmények.append (acc)
eredmény visszaadása
|
ezután betölthetjük adatkészletünket, kiértékelhetjük a modellt, és jelenthetjük az átlagos teljesítményt.
ezt összekapcsolva a teljes példát az alábbiakban soroljuk fel.
|
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 a többcímkés osztályozáshoz
a numpy import átlagától
a numpy import std-től
a sklearn-tól.adatkészletek importálása make_multilabel_classification
a sklearn-ból.model_selection import RepeatedKFold
a keras-tól.a modellek szekvenciális
– et importálnak a keras-ból.rétegek import sűrű
származó sklearn.metrics import accuracy_score
# szerezd meg az adatkészletet
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
# szerezd meg a modellt
def get_model(n_inputs, n_outputs):
model = sequential()
model.add (sűrű(20, input_dim=n_inputs, kernel_initializer= ‘he_uniform’, activation= ‘relu’))
modell.add (sűrű(n_outputs, activation= ‘sigmoid’))
modell.compile(loss=’binary_crossentropy’, optimizer=’adam’)
visszatérési modell
# modell értékelése ismételt k-szeres keresztellenőrzéssel
def evaluate_model(X, y):
eredmények = lista()
n_inputs, n_outputs = X. alak, y.alak
# értékelési eljárás meghatározása
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# sorolja fel a
hajtásokat a train_ix, test_ix cv-ben.split(x):
# adatok előkészítése
x_train, X_test = X, X
y_train, y_test = y, y
# modell meghatározása
model = get_model(n_inputs, n_outputs)
# fit modell
modell.fit (X_train, y_train, bőbeszédű=0, korszakok=100)
# készítsen előrejelzést a tesztkészleten
yhat = modell.predict (X_test)
# kerek valószínűségek osztálycímkékhez
yhat = yhat.kerek ()
# a pontosság kiszámítása
acc = accuracy_score (y_test, yhat)
# az eredmény tárolása
nyomtatás (‘>%.3f ‘ % acc)
eredmények.append(acc)
eredmény visszaadása
# adatkészlet betöltése
X, y = get_dataset()
# modell értékelése
eredmények = evaluate_model(X, y)
# teljesítmény összegzése
nyomtatás(‘pontosság: %.3f (%.3f) ‘ % (átlag (eredmények), std (eredmények)))
|
a példa futtatása az egyes hajtogatások és ismétlések osztályozási pontosságát jelenti, hogy képet adjon az értékelés előrehaladásáról.
Megjegyzés: Az eredmények változhatnak, tekintettel az algoritmus vagy az értékelési eljárás sztochasztikus jellegére vagy a numerikus pontosság különbségeire. Fontolja meg a példa futtatását néhányszor, és hasonlítsa össze az átlagos eredményt.
a végén az átlagos és a szórás pontosságát jelentik. Ebben az esetben a modell körülbelül 81,2 százalékos pontosságot ér el.
ezt a kódot sablonként használhatja az MLP modellek értékeléséhez a saját többcímkés osztályozási feladataiban. A modellben található csomópontok és rétegek száma könnyen adaptálható és testreszabható az adatkészlet összetettségéhez.
|
1
2
3
4
5
6
7
|
…
>0.780
>0.820
>0.790
>0.810
>0.840
pontosság: 0.812 (0.032)
|
Miután kiválasztottuk a modellkonfigurációt, felhasználhatjuk arra, hogy az összes rendelkezésre álló adatra beleférjen egy végleges modell, és előrejelzést készítsünk az új adatokra.
az alábbi példa ezt úgy mutatja be, hogy először az MLP modellt illeszti a teljes többcímkés osztályozási adatkészletbe, majd meghívja a predict() függvényt A mentett modellen annak érdekében, hogy előrejelzést készítsen egy új adatsorra.
|
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
|
# mlp használata az előrejelzéshez többcímkés osztályozás esetén
a numpy import asarray-től
a sklearn-tól.adatkészletek importálása make_multilabel_classification
a keras-ból.a modellek szekvenciális
– et importálnak a keras-ból.rétegek import sűrű
# szerezd meg az adatkészletet
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
visszatérés X, Y
# szerezd meg a modellt
def get_model(n_inputs, n_outputs):
model = sequential()
model.add (sűrű(20, input_dim=n_inputs, kernel_initializer= ‘he_uniform’, activation= ‘relu’))
modell.add (sűrű(n_outputs, activation= ‘sigmoid’))
modell.compile(loss=’binary_crossentropy’, optimizer=’adam’)
visszatérési modell
# adatkészlet betöltése
X, y = get_dataset()
n_inputs, n_outputs = X. shape, y.shape
# get model
model = get_model(n_inputs, n_outputs)
# illessze be a modellt minden adatra
modell.fit (X, y, bőbeszédű=0, korszakok=100)
# készítsen előrejelzést az új adatokhoz
sor =
newX = asarray()
yhat = modell.jóslás (newX)
nyomtatás (‘jósolt: %s’ % yhat)
|
a példa futtatása illeszkedik a modellhez, és előrejelzést ad egy új sorra. A várakozásoknak megfelelően az előrejelzés három kimeneti változót tartalmaz, amelyek szükségesek a többcímkés osztályozási feladathoz: az egyes osztálycímkék valószínűségeit.
|
1
|
jósolt:
|
további olvasmányok
ez a szakasz további forrásokat tartalmaz a témáról, ha mélyebbre szeretne menni.
- többcímkés osztályozás, Wikipédia.
- sklearn.adatkészletek.make_multilabel_classification API.
- Keras honlapja.
- sklearn.model_selection.RepeatedStratifiedKFold API.
összefoglaló
ebben az oktatóanyagban felfedezted, hogyan lehet mély tanulási modelleket fejleszteni a többcímkés osztályozáshoz.
konkrétan megtanultad:
- a többcímkés osztályozás egy prediktív modellezési feladat, amely magában foglalja a nulla vagy több kölcsönösen nem kizárólagos osztálycímke előrejelzését.
- neurális hálózati modellek konfigurálhatók többcímkés osztályozási feladatokhoz.
- hogyan értékeljünk egy neurális hálózatot a többcímkés osztályozáshoz és készítsünk előrejelzést az új adatokra.
van kérdése?
tegye fel kérdéseit az alábbi megjegyzésekben, és mindent megteszek, hogy válaszoljak.
fejleszteni mély tanulási projektek Python!
mi lenne, ha percek alatt fejlesztene egy hálózatot
…csak néhány sor Python
fedezze fel, hogyan az én új Ebook:
Deep Learning with Python
kiterjed end-to-end projektek témákban, mint:
többrétegű Perceptrons, konvolúciós hálók és visszatérő neurális hálók, és így tovább…
végül hozzon mély tanulást
saját projektjeihez
hagyja ki az akadémikusokat. Csak Eredmények.
nézze meg, mi van benne
Tweet Megosztás Megosztás
