Tweet Share Share
Last Updated on August 31, 2020
Multi-label classification includes predicting zero or more class labels.
w przeciwieństwie do zwykłych zadań klasyfikacyjnych, w których etykiety klas wzajemnie się wykluczają, klasyfikacja wielu etykiet wymaga wyspecjalizowanych algorytmów uczenia maszynowego, które wspierają przewidywanie wielu wzajemnie niewyłącznych klas lub etykiet.”
Sieci neuronowe głębokiego uczenia są przykładem algorytmu, który natywnie obsługuje problemy z klasyfikacją wielu etykiet. Modele sieci neuronowych do zadań klasyfikacji wielu etykiet można łatwo definiować i oceniać za pomocą biblioteki keras Deep learning library.
w tym samouczku dowiesz się, jak opracować modele głębokiego uczenia do klasyfikacji wielu etykiet.
po ukończeniu tego kursu dowiesz się:
- klasyfikacja wielu etykiet jest zadaniem modelowania predykcyjnego, które obejmuje przewidywanie zerowych lub więcej wzajemnie niewyłącznych etykiet klas.
- modele sieci neuronowych można skonfigurować do zadań klasyfikacji wielu etykiet.
- jak oceniać sieć neuronową pod kątem klasyfikacji multi-label i przewidywać nowe dane.
zaczynajmy.
Klasyfikacja Multi-Label z Deep Learning
Zdjęcie Trevor Marron, niektóre prawa zastrzeżone.
opis poradnika
ten poradnik jest podzielony na trzy części; są to:
- Klasyfikacja wielu etykiet
- Sieci neuronowe dla wielu etykiet
- sieć neuronowa dla wielu etykiet
Klasyfikacja wielu etykiet
klasyfikacja jest problemem modelowania predykcyjnego, który polega na wyprowadzeniu etykiety klasy z pewnym wkładem
różni się od zadań regresji, które obejmują przewidywanie wartości liczbowej.
zazwyczaj zadanie klasyfikacji polega na przewidywaniu pojedynczej etykiety. Alternatywnie, może to obejmować przewidywanie prawdopodobieństwa dla dwóch lub więcej etykiet klas. W takich przypadkach klasy wzajemnie się wykluczają, co oznacza, że zadanie klasyfikacji zakłada, że dane wejściowe należą tylko do jednej klasy.
niektóre zadania klasyfikacji wymagają przewidywania więcej niż jednej etykiety klasy. Oznacza to, że etykiety klas lub członkostwo w klasach nie wykluczają się wzajemnie. Zadania te są określane jako klasyfikacja wielu etykiet lub klasyfikacja wielu etykiet w skrócie.
w klasyfikacji multi-label, zero lub więcej etykiet są wymagane jako wyjście dla każdej próbki wejściowej, A wyjścia są wymagane jednocześnie. Zakłada się, że etykiety wyjściowe są funkcją wejść.
możemy utworzyć syntetyczny zestaw danych klasyfikacji wielu etykiet za pomocą funkcji make_multilabel_classification() w bibliotece scikit-learn.
nasz zbiór danych będzie miał 1000 próbek z 10 funkcjami wejściowymi. Zestaw danych będzie miał trzy wyjścia etykiet klas dla każdej próbki i każda klasa będzie miała jedną lub dwie wartości (0 LUB 1, np. present or not present).
kompletny przykład tworzenia i podsumowania syntetycznego zestawu danych klasyfikacji wielu etykiet znajduje się poniżej.
|
1
2
3
4
5
6
7
8
9
|
# przykład zadania z klasyfikacją wielu etykiet
ze sklepu.import zestawów danych 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)
# podsumuj kształt zestawu danych
Drukuj(X. kształt, y.kształt)
# podsumuj kilka pierwszych przykładów
dla i w zakresie(10):
print (X, y)
|
uruchomienie przykładu tworzy zestaw danych i podsumowuje kształt elementów wejściowych i wyjściowych.
widzimy, że zgodnie z oczekiwaniami istnieje 1000 próbek, każdy z 10 funkcjami wejściowymi i trzema funkcjami wyjściowymi.
pierwsze 10 wierszy wejść i wyjść jest podsumowane i widzimy, że wszystkie wejścia dla tego zestawu danych są numeryczne i że etykiety klas wyjściowych mają wartości 0 LUB 1 dla każdej z trzech etykiet klas.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
(1000, 10) (1000, 3)
|
następnie przyjrzyjmy się, w jaki sposób możemy opracować modele sieci neuronowych do zadań klasyfikacji wielu etykiet.
Sieci neuronowe dla wielu etykiet
niektóre algorytmy uczenia maszynowego natywnie obsługują klasyfikację wielu etykiet.
modele sieci neuronowych można skonfigurować tak, aby obsługiwały klasyfikację wielu etykiet i mogą działać dobrze, w zależności od specyfiki zadania klasyfikacji.
klasyfikacja wielu etykiet może być obsługiwana bezpośrednio przez sieci neuronowe, po prostu określając liczbę etykiet docelowych w problemie jako liczbę węzłów w warstwie wyjściowej. Na przykład zadanie z trzema etykietami wyjściowymi (klasami) będzie wymagało warstwy wyjściowej sieci neuronowej z trzema węzłami w warstwie wyjściowej.
każdy węzeł w warstwie wyjściowej musi użyć aktywacji esicy. Pozwoli to przewidzieć prawdopodobieństwo członkostwa w klasie dla etykiety, wartość od 0 do 1. Wreszcie, model musi być dopasowany do binarnej funkcji utraty entropii krzyżowej.
podsumowując, aby skonfigurować model sieci neuronowej do klasyfikacji wielu etykiet, specyfikacjami są:
- Liczba węzłów w warstwie wyjściowej odpowiada liczbie etykiet.
- aktywacja esicy dla każdego węzła w warstwie wyjściowej.
- binarna funkcja utraty entropii krzyżowej.
możemy to zademonstrować za pomocą biblioteki keras deep learning.
zdefiniujemy wielowarstwowy Model perceptronu (MLP) dla zadania klasyfikacji wielu etykiet zdefiniowanego w poprzedniej sekcji.
każda próbka ma 10 wejść i trzy wyjścia; dlatego sieć wymaga warstwy wejściowej, która oczekuje 10 wejść określonych za pomocą argumentu „input_dim” w pierwszej ukrytej warstwie i trzech węzłów w warstwie wyjściowej.
użyjemy popularnej funkcji aktywacji ReLU w ukrytej warstwie. Ukryta warstwa ma 20 węzłów, które zostały wybrane po próbach i błędach. Dopasujemy model wykorzystując binarną stratę entropii krzyżowej i wersję Adam Stochastic gradient descent.
definicja sieci dla zadania klasyfikacji wielu etykiet znajduje się poniżej.
|
1
2
3
4
5
|
# zdefiniuj model
model = Sequential()
model.dodaj(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.dodaj(Dense (n_outputs, activation=’sigmoid’))
model.compile (loss= 'binary_crossentropy’, optimizer= 'adam’)
|
możesz dostosować ten model do własnego zadania klasyfikacji wielu etykiet; dlatego możemy utworzyć funkcję do definiowania i zwracania modelu, w którym liczba zmiennych wejściowych i wyjściowych jest podawana jako argumenty.
|
1
2
3
4
5
6
7
|
# Pobierz model
def get_model (n_inputs, n_outputs):
model = Sequential ()
model.dodaj(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.dodaj(Dense (n_outputs, activation=’sigmoid’))
model.compile (loss=’binary_crossentropy’, optimizer=’adam’)
return model
|
teraz, gdy już wiemy, jak zdefiniować MLP dla klasyfikacji wielu etykiet, przyjrzyjmy się, w jaki sposób ten model może być oceniany.
sieć neuronowa do klasyfikacji Multi-Label
jeśli zestaw danych jest mały, dobrą praktyką jest wielokrotna ocena modeli sieci neuronowych na tym samym zestawie danych i raportowanie średniej wydajności w powtórzeniach.
wynika to ze stochastycznej natury algorytmu uczenia się.
ponadto dobrą praktyką jest stosowanie K-fold cross-validation zamiast podziału pociągu / testu zestawu danych, aby uzyskać bezstronne oszacowanie wydajności modelu podczas przewidywania nowych danych. Ponownie, tylko wtedy, gdy nie ma zbyt wiele danych, że proces może zostać zakończony w rozsądnym czasie.
biorąc to pod uwagę, będziemy oceniać model MLP w zadaniu regresji multi-output za pomocą powtarzanej weryfikacji krzyżowej K-fold z 10 fałdami i trzema powtórzeniami.
model MLP domyślnie przewiduje prawdopodobieństwo dla każdej etykiety klasy. Oznacza to, że będzie przewidywać trzy prawdopodobieństwa dla każdej próbki. Można je przekonwertować na wyraźne etykiety klas, zaokrąglając wartości do 0 LUB 1. Następnie możemy obliczyć dokładność klasyfikacji dla etykiet klasy crisp.
|
1
2
3
4
5
6
7
|
…
# wykonaj prognozę na zestawie testowym
yhat = model . predict (X_test)
# round probability to class labels
yhat = yhat.round()
# Oblicz dokładność
acc = accuracy_score (y_test, yhat)
|
wyniki są zbierane i można je podsumować, zgłaszając średnią i odchylenie standardowe we wszystkich powtórzeniach i fałdach weryfikacji krzyżowej.
funkcja evaluate_model () poniżej pobiera zestaw danych, ocenia model i zwraca listę wyników oceny, w tym przypadku, wyników dokładności.
|
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
|
# ocena modelu przy użyciu wielokrotnego K-fold cross-validation
def evaluate_model (X, y) :
results = list ()
n_inputs, n_outputs = X. shape, Y.shape
# zdefiniuj procedurę oceny
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# wylicz fałdy
dla train_ix, test_ix w cv.split(X):
# przygotuj dane
X_train, X_test = X, X
y_train, y_test = y, y
# zdefiniuj model
model = get_model(n_inputs, n_outputs)
# dopasuj model
model.fit (X_train, y_train, verbose=0, epochs=100)
# wykonaj predykcję na zestawie testowym
yhat = model . predict (X_test)
# round probability to class labels
yhat = yhat.round()
# Oblicz dokładność
acc = accuracy_score(y_test, yhat)
# przechowuj wynik
Drukuj(’>%.3F ’ % acc)
wyniki.append (acc)
zwróć wyniki
|
następnie możemy załadować nasz zestaw danych i ocenić model i zgłosić średnią wydajność.
|
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 do klasyfikacji wielu etykiet
z importu numpy średnia
z importu numpy std
ze sklepu.zbiory danych importują make_multilabel_classification
ze sklepu.model_selection import RepeatedKFold
z keras.modele importują sekwencje
z keras.warstwy importują gęste
ze sklepu.metryka import dokładności_score
# pobierz zestaw danych
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
# Pobierz model
def get_model(n_inputs, n_outputs):
model = sequential()
model.dodaj(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.dodaj(Dense (n_outputs, activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’)
return model
# Oceń model przy użyciu powtarzanej K-krotnie weryfikacji krzyżowej
def evaluate_model (X, y):
results = list ()
n_inputs, n_outputs = X. kształt, Y.shape
# define evaluation procedure
cv = RepeatedKFold (n_splits=10, n_repeats = 3, random_state=1)
# wylicz fałdy
dla train_ix, test_ix w cv.split(X):
# przygotuj dane
X_train, X_test = X, X
y_train, y_test = y, y
# zdefiniuj model
model = get_model(n_inputs, n_outputs)
# dopasuj model
model.fit (X_train, y_train, verbose=0, epochs=100)
# wykonaj predykcję na zestawie testowym
yhat = model . predict (X_test)
# round probability to class labels
yhat = yhat.round()
# Oblicz dokładność
acc = accuracy_score(y_test, yhat)
# przechowuj wynik
Drukuj(’>%.3F ’ % acc)
wyniki.Dołącz(acc)
zwróć wyniki
# załaduj zestaw danych
X, y = get_dataset()
# Oceń model
wyniki = evaluate_model(X, y)
# podsumuj wydajność
Print(’dokładność: %.3f (%.3f) ” % (średnia (wyniki), std (wyniki)))
|
uruchomienie przykładu raportuje dokładność klasyfikacji dla każdego zagięcia i każdego powtórzenia, aby dać wyobrażenie o postępie oceny.
Uwaga: Twoje wyniki mogą się różnić ze względu na stochastyczny charakter algorytmu lub procedury oceny lub różnice w precyzji numerycznej. Rozważ uruchomienie przykładu kilka razy i porównaj średni wynik.
na końcu podaje się średnią i standardową dokładność odchylenia. W tym przypadku model jest pokazany, aby osiągnąć dokładność około 81,2 procent.
możesz użyć tego kodu jako szablonu do oceny modeli MLP na własnych zadaniach klasyfikacji wielu etykiet. Liczbę węzłów i warstw w modelu można łatwo dostosować i dostosować do złożoności zbioru danych.
|
1
2
3
4
5
6
7
|
…
>0.780
>0.820
>0.790
>0.810
>0.840
Dokładność: 0.812 (0.032)
|
Po wybraniu konfiguracji modelu możemy jej użyć, aby dopasować ostateczny model do wszystkich dostępnych danych i przewidzieć nowe dane.
poniższy przykład pokazuje to, najpierw dopasowując model MLP do całego zestawu danych klasyfikacji wielu etykiet, a następnie wywołując funkcję predict() w zapisanym modelu w celu dokonania prognozy dla nowego wiersza danych.
|
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
|
# użyj mlp do przewidywania w klasyfikacji wielu etykiet
z numpy import asarray
ze sklepu.zbiory danych importują make_multilabel_classification
z keras.modele importują sekwencje
z keras.Importuj warstwy gęste
# pobierz zestaw danych
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
# Pobierz model
def get_model(n_inputs, n_outputs):
model = sequential()
model.dodaj(Dense (20, input_dim=n_inputs, kernel_initializer=’he_uniform’, activation=’relu’))
model.dodaj(Dense (n_outputs, activation=’sigmoid’))
model.compile (loss=’binary_crossentropy’, optimizer=’adam’)
return model
# load dataset
X, y = get_dataset ()
n_inputs, n_outputs = X. shape, Y.shape
# Pobierz model
model = get_model (n_inputs, n_outputs)
# dopasuj model do wszystkich danych
modelu.fit (X, y, verbose=0, epochs=100)
# wykonaj predykcję dla nowych danych
row =
newX = asarray()
yhat = model.predict (newX)
print (’predict: %s’ % yhat)
|
uruchomienie przykładu pasuje do modelu i tworzy prognozę dla nowego wiersza. Zgodnie z oczekiwaniami, prognoza zawiera trzy zmienne wyjściowe wymagane do zadania klasyfikacji wielu etykiet: prawdopodobieństwo każdej etykiety klasy.
|
1
|
przewidywane:
|
Czytaj dalej
Ta sekcja zawiera więcej zasobów na ten temat, jeśli chcesz zagłębić się w ten temat.
- klasyfikacja wielotematyczna, Wikipedia.
- sklepzbiory danych.make_multilabel_classification API.
- Strona domowa Keras.
- sklepmodel_selection.API RepeatedStratifiedKFold.
podsumowanie
w tym samouczku odkryłeś, jak opracować modele uczenia głębokiego do klasyfikacji wielu etykiet.
konkretnie, nauczyłeś się:
- klasyfikacja wielu etykiet jest zadaniem modelowania predykcyjnego, które obejmuje przewidywanie zerowych lub więcej wzajemnie niewyłącznych etykiet klas.
- modele sieci neuronowych można skonfigurować do zadań klasyfikacji wielu etykiet.
- jak oceniać sieć neuronową pod kątem klasyfikacji multi-label i przewidywać nowe dane.
masz pytania?
Zadawaj pytania w komentarzach poniżej, a ja postaram się odpowiedzieć.
rozwijaj projekty Deep Learning z Pythonem!
co by było, gdybyś mógł stworzyć sieć w kilka minut
…dzięki kilku liniom Pythona
dowiedz się, jak w moim nowym ebooku:
Deep Learning with Python
obejmuje on kompleksowe projekty dotyczące takich tematów jak:
Wielowarstwowe Perceptrony, sieci Konwolucyjne i Sieci neuronowe nawracające i wiele innych…
wreszcie wprowadź głębokie uczenie do
własnych projektów
Pomiń naukowców. Tylko Wyniki.
Zobacz co jest w środku
Udostępnij Udostępnij
