Klasyfikacja : przykładowe rozwiązanie w Python

Mamy zmienną X, która jest pewnym badanym zbiorem. Jest ona charakteryzowana przez trzy parametry :

X = [[181, 80, 44], [177, 70, 43], [160, 60, 38], [154, 54, 37],[166, 65, 40],
[190, 90, 47],[175, 64, 39],[177, 70, 40], [159, 55, 37],
[171, 75, 42], [181, 85, 43], [168, 75, 41],[168, 77, 41],
[190, 70, 43],[154, 75, 38],[181,65,40]]

Mamy zmienną dychotomiczną Y, która jest zbiorem odpowiadającym zmiennej X :

Y = ['x', 'x', 'y', 'y', 'x', 'x', 'y', 'y', 'y', 'x', 'x', 'y', 'y', 'x','y','x']

Na podstawie powyższych danych, należy zbudować model, który pozwoli nam zaklasyfikować dane, które możemy otrzymać.

Rozwiązanie:

Zmienna Y posłuży nam do uczenia naszego modelu.

Ze zbioru X i Y należy wyodrębnić dane testowe. Zbiory te zostaną pomniejszone o wyodrębnione elementy. Dane testowe jak sama nazwa mówi, posłużą nam do przetestowania, czy otrzymane przez nas wyniki są prawidłowe. Do testu należy wyodrębnić 25% danych:

X = [[181, 80, 44], [177, 70, 43], [160, 60, 38], [154, 54, 37],[166, 65, 40], [190, 90, 47], [175, 64, 39],
     [177, 70, 40], [159, 55, 37], [171, 75, 42],
     [181, 85, 43], [168, 77, 41]]
Y = ['x', 'x', 'y', 'y', 'x', 'x', 'y', 'y', 'y', 'x', 'x', 'y']

test_data = [[190, 70, 43], [154, 75, 38], [181, 65, 40], [168, 75, 41]]
test_labels = ['x', 'y', 'x', 'y']

Czyli zasada jest taka, że na podstawie danych X, Y testujemy nasze modele, następnie testujemy dane 'test_data’ i wynik porównujemy z danymi 'test_labels’.

Do naszego badania wykorzystamy najbardziej standardowe modele (klasyfikatory):

• Drzewa decyzyjne
• Decyzyjny las losowy
• Regresja logistyczna (działa lepiej na większych danych)
• SVC – metoda wektorów podporowych (lub wspierających)
• k-najbliższych sąsiadów

Używamy bibliotek:

from sklearn import tree
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
import numpy as np
from sklearn.metrics import accuracy_score

Należy ustawić wstępne parametry klasyfikatorów na zero:

dtc_tree_acc = 0
rfc_acc = 0
l_acc = 0
s_acc = 0
kNB_acc = 0

Budując model na początku tworzymy instancję niektórych przypadkach konieczne jest podanie parametrów). Następnie korzystamy z metody fit. Na końcu robimy predykcję

Dla każdego z modeli wykonujemy 100 iteracji testu. Jest to konieczne, ponieważ nasz model nie zawsze przewidzi taki sam wynik. Otrzymane wyniki dodajemy do siebie za pomocą funkcji, która porównuje poszczególne elementy i zwróci procent w postaci ułamka elementów które są zgodne :

for i in range(100):
     # Drzewa decyzyjne

     dtc_clf = tree.DecisionTreeClassifier()
     dtc_clf = dtc_clf.fit(X, Y)
     dtc_prediction = dtc_clf.predict(test_data)
     # print(dtc_prediction)

     # Decyzyjny las losowy

     rfc_clf = RandomForestClassifier(n_estimators=100)
     rfc_clf.fit(X, Y)
     rfc_prediction = rfc_clf.predict(test_data)
     # print(rfc_prediction)

     # Regresja logistyczna

     l_clf = LogisticRegression(solver='lbfgs')
     l_clf.fit(X, Y)
     l_prediction = l_clf.predict(test_data)
     # print(l_prediction)

     SVC
     #

     s_clf = SVC(gamma='scale')
     s_clf.fit(X, Y)
     s_prediction = s_clf.predict(test_data)
     # print(s_prediction)

     # k- najblizszych sasiadow

     kNB_clf = KNeighborsClassifier()
     kNB_clf.fit(X, Y)
     kNB_prediction = kNB_clf.predict(test_data)
     # print(kNB_prediction)

     # Dokładnosc

     dtc_tree_acc += accuracy_score(dtc_prediction, test_labels)
     rfc_acc += accuracy_score(rfc_prediction, test_labels)
     l_acc += accuracy_score(l_prediction, test_labels)
     s_acc += accuracy_score(s_prediction, test_labels)
     kNB_acc += accuracy_score(kNB_prediction, test_labels)

Wyświetlamy wyniki, oraz porównanie dla poszczególnych klasyfikatorów:

print('Drzewo decyzyjne', dtc_tree_acc, '\nDecyzyjny las losowy', rfc_acc, '\nRegresja logistyczna',
l_acc, '\nSVC', s_acc,
      '\nNajbliżsi sąsiedzi', kNB_acc)

klasyfikatory = ['Drzewo decyzyjne', 'Decyzyjny las losowy', 'Regresja logistyczna','SVC',
'Najbliżsi sąsiedzi']
dokładnosc = np.array([dtc_tree_acc, rfc_acc, l_acc, s_acc, kNB_acc])
max_acc = np.argmax(dokładnosc)
print('\n' + klasyfikatory[max_acc] + ' jest najlepszym klasyfikatorem problemu.\n')

Uzyskany wynik:
Drzewo decyzyjne 81.75 
Decyzyjny las losowy 89.75 
Regresja logistyczna 50.0 
SVC 100.0 
Najbliżsi sąsiedzi 75.0
SVC jest najlepszym klasyfikatorem problemu. Przewidział za każdym razem prawidłowy wynik.