Support Vector Machine zaliczany jest do estymatorów machine learning uczenia z nadzorem w oparciu o procesy klasyfikacji i analizy regresji.

Klasyfikator SVM wykorzystuje algorytm optymalizacji w oparciu o maksymalizację marginesu hiperplanu. Algorytm SVM jest przeznaczony do prowadzenia możliwie najlepszej klasyfikacji wyników. Wektory oddzielające hiperprzestrzenie mogą mieć charakter liniowy lub (dzięki funkcji SVC) nieliniowy.

W naszym modelu zastosujemy liniowy klasyfikator SVM.

Ćwiczenie przeprowadzimy na próbce badań laboratoryjnych przeprowadzonych na 768 pacjentów. Dane do ćwiczenia z pełnym opisem można znaleźć tutaj: https://www.kaggle.com/kumargh/pimaindiansdiabetescsv

Na początek otworzymy bazę wraz z niezbędnymi bibliotekami.

import pandas as pd 
import numpy as np 
import matplotlib.pyplot as plt
import seaborn as sns
import pprint

from sklearn.pipeline import Pipeline
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.externals import joblib


df = pd.read_csv('c:/1/diabetes.csv', usecols=['Pregnancies', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'Age', 'Outcome'])
df.head(3)

Dokonujemy wyboru funkcji celu y jako kolumny 'Outcome’ oraz usuwamy tą kolumnę ze zbioru zmiennych opisujących X.

X=df.drop(['Outcome'],axis=1)
Y=df['Outcome']

Transformacja i klasyfikacja

Tworzymy obiektu pipeline jako połączenie transformatora i klasyfikatora.

Transformator ‘StandardScaler()’ standaryzuje zmienne do populacji opisanej na standaryzowanym rozkładzie normalnym.

Jako estymatora użyliśmy Support Vector Machine (SVM) specjalizującym się w klasyfikacji próbek w kierunku maksymalizacji marginesu pomiędzy grupami danych.

W tym badaniu przyjmiemy klasyfikator liniowy.

ew = [('scaler', StandardScaler()), ('SVM', SVC())]
pipeline = Pipeline(ew)

Istnieją dwa parametry dla jądra SVM, mianowicie C i gamma. Powinniśmy ustawić siatkę parametrów przy użyciu wielokrotności 10. Deklarujemy przestrzeń hiperparametrów. Najlepsza konfiguracja hiperparametrów zostanie wybrana w drodze dostrajania modelu przez GridSearchCV.

parameteres = {'SVM__C':[0.001,0.1,10,100,10e5], 'SVM__gamma':[0.1,0.01]}

Tworzymy zestaw danych do dalszej transformacji i estymacji. Przyjmujemy 20

X_train, X_test, y_train, y_test = train_test_split(X,Y,test_size=0.2, random_state=30, stratify=Y)

Parametr stratify=y powoduje odwzorowanie struktury estymatora do struktury populacji. Dzięki temu parametrowi proporcje określonych wartości w próbce testowej będą taki sam, jak proporcja  w próbce treningowej.

Dostrajanie modelu

grid = GridSearchCV(pipeline, param_grid=parameteres, cv=5)
grid.fit(X_train, y_train)

Powyższy kod odpowiada za dostrajanie modelu.

Istnieją dwa sposoby szukania najlepszych hiperpartametrów do dostrojenia modelu:

• szukanie przez siatkę (tzw. ‘Grid’)
• szukanie losowe

GridSearchCV – nielosowa metoda dostrajania modelu siatki.

W Pipeline wskazaliśmy metody transformatora: StandardScaler() i estymator: Support Vector Machine.

Następnie w kodzie Hyperparameters – wskazaliśmy parametry: 'SVM__C'oraz 'SVM__gamma'.

Ponieważ używamy GridSearchCV, ta funkcja decyduje o najlepszej wartości w 'SVM__C' i innych zadanych hiperparametrach w zależności od tego, jak dobrze klasyfikator działa na zbiorze danych.

Zobaczmy jakie parametry są najlepsze według GridSearchCV:

pparam=pprint.PrettyPrinter(indent=2)
print(grid.best_params_)

Czas sprawdzić, na ile nasz model jest dobry, na ile trafnie opisuje rzeczywistość.

Przypomnijmy że celem modelu było wskazanie na podstawie wyników badań czy dany pacjent jest chory na cukrzycę czy nie. Czyli odpowiedź modelu w postaci zmiennej zależnej y powinien wynosić 0 lub 1.

y_pred = grid.predict(X_test)
y_pred = np.round(y_pred, decimals=0)

Ocena modelu przez Confusion Matrix

Do oceny naszego modelu tworzącego odpowiedzi binarne, użyjemy Confusion Matrix.

Macierz wskazuje na ile model trafnie typuje odpowiedzi. Zestawia się tu odpowiedzi ze zbioru testowego z odpowiedziami uzyskanymi w drodze predykcji.

from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred)) 

Macierz ma dwa wymiary ponieważ odpowiedzi mają charakter binarny.

Jak interpretować Confusion Matrix?

Macierz wskazuje ile razy model trafnie wytypował odpowiedź a ile razy się pomylił.

Liczby w polach białych oznaczają ilość trafnych typowań, zaś liczby w czarnych polach oznaczają typowania błędne. Intuicyjnie będziemy lepiej oceniali modele, które mają istotną przewagę w polach białych nad polami czarnymi.

 Celność modelu  (accuracy (ACC)) jest interpretowana jako dokładność klasyfikacji. Jest liczona jako suma liczb z białych pól do sumy liczb ze wszystkich pól: ACC = A+D / A+B+C+D. Czym wyższa wartość procentowa tym lepiej.

 Precyzja modelu  (precision or positive predictive value (PPV)) czyli poziom sprawdzalności prognoz modelu. Jest liczona jako PPV = A / A+B.

 Odwołanie modelu  (sensitivity, recall, hit rate, or true positive rate (TPR))– w ilu przypadkach obecni pacjenci z cukrzycą  są identyfikowani przez model jako chorzy. Jest liczona jako   TPR = A / A+C.

 F-Score 

Trudno jest porównać model z niskim  Precision i wysokim Recall i odwrotnie.

Aby porównać modele należy użyć F-Score, które mierzy  jednocześnie Recall i Precision.

F-Score = (2* Precision* Recall)/( Precision+ Recall) = 2A/(2A+B+C)

Porównanie estymatorów

Teraz zestawimy model oparty o estymator Support Vector Machine z modelem z poprzedniego przykładu opartym o estymator Random Forest.

Widzimy, że wyniki estymacji Support Vector Machine versus Random Forest niewiele się różnią.

Praktyczne użycie modelu Machine learning

Model możemy zapisać używając kodu:

joblib.dump(grid, 'c:/1/rf_SVM.pkl')

Możemy odczytać zapisany wcześniej model:

clf2 = joblib.load('c:/1/rf_SVM.pkl')

Wyniki predykcji możemy podstawić do wynikowych danych empirycznych.

lf2.predict(X_test)
X = df.drop('Outcome', axis=1)
WYNIK = clf2.predict(X)
df['MODEL'] = pd.Series(WYNIK)

df['Result'] = df['MODEL'] - df['Outcome']
df[['Outcome','MODEL', 'Result']].sample(10)

cdf['Result'].value_counts()

df['Result'].value_counts(normalize=True)

Machine Learning w medycynie

W tym badaniu użyto metody Random Forest.

Naszym celem jest zbudowanie modelu uczenia maszynowego do predykcji zapadalności na cukrzycę.

Próbkę danych, nad którą będziemy dzisiaj pracowali, wraz z opisem można znaleźć tutaj: https://www.kaggle.com/kumargh/pimaindiansdiabetescsv

Z modelu usunęliśmy zmienną egzogeniczną: ‘Glucose’ ponieważ wykazywała się ona zbyt wysoką korelacją z wartością wynikową. Istnienie doskonałego estymatora oznaczało zmniejszenie w modelu znaczenia pozostałych mniej doskonałych estymatorów.

Przekładając to na język polski, sam poziom glukozy wskazuje czy ktoś jest chory na cukrzycę. Estymator ten jest więc utożsamiany z pojawieniem się choroby a nie z czynnikiem ją wywołującym.

Wczytanie bazy

Otwieram bazę wraz z niezbędnymi bibliotekami. Wyświetlam 5 pierwszych rekordów bazy.

import pandas as pd
import numpy as np

df = pd.read_csv('c:/1/diabetes.csv', usecols=['Pregnancies', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'Age', 'Outcome'])
df.head(5)

W tabeli są ewidentne błędy: ciśnienie krwi równe zero, zerowy poziom insuliny czy grubość skóry.

Usunięcie tych błędów nie mają większego wpływu na dobroć modelu. Można łatwo to sprawdzić wprowadzając do kodu poniższą instrukcje usuwającą błędne rekordy.

df[['Pregnancies', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'Age']] = df[['Pregnancies', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'Age']].replace(0,np.nan)
df = df.dropna(how='any')

Wskazanie zmiennych egzogenicznych i zmiennej endogenicznej

Teraz wskazuje, która z kolumn jest kolumną wynikową y, zawierającą zmienne zależne.

Kolumnę wynikową y usuwamy z DataFrame tworząc zestaw danych opisujących X, czyli kolumny zawierające zmienne niezależne.

y = data.Outcome
X = data.drop('Outcome', axis=1)

Tworzymy zestaw danych do dalszej transformacji i estymacji.

Przyjmujemy 80

Parametr ‘random_state’ określa stabilność, nie ma znaczenia liczba jaką tam wpiszemy. Opuszczenie parametru ‘random_state’ będzie powodowało, że model przy każdym uruchomieniu będzie generował inne wartości losowe, co będzie prowadziło do destabilizacji obliczeń.

Parametr stratify=y powoduje odwzorowanie struktury estymatora do struktury populacji. Dzięki temu parametrowi proporcje określonych wartości w próbce testowej będzie taki sam, jak proporcja określonych wartości w próbce treningowej.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=123,stratify=y)

Obiekt Pipline

Teraz tworzymy zespół transformatora z estymatorem, elementem scalającym jest obiekt pipeline.

Transformator preprocessing.StandardScaler() tworzy standaryzację danych do postaci rozkładu normalnego o średniej 0 i odchyleniu standardowym 1.

Estymator Random Forest tworzy model zachowania zmiennej zależnej w stosunku do przebiegu zmiennych niezależnych. Estymatorem jest w naszym przykładzie RandomForestRegressor(n_estimators=100).

from sklearn.pipeline import make_pipeline
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor

pipeline = make_pipeline(preprocessing.StandardScaler(), RandomForestRegressor(n_estimators=100))

Parametr n_estimators=100 dla Random Forest wskazuje ile drzew decyzyjnych zostanie uruchomionych w trakcie procesu tworzenia modelu. Zwiększenie liczby drzew do np. 1000 może spowodować nieznaczną poprawę trafności modelu, wydłuży jednak czas trwania obliczeń. Sztuką jest znalezienie złotego środka między czasem realizacji obliczeń i trafnością obliczeń.

Deklarowanie hiperparametrów

Teraz tworzymy hiperparametry do dostrojenia modelu. W tej linijce kodu deklarujemy jakimi metodami zamierzamy dostrajać i optymalizować model.

hyperparameters = {'randomforestregressor__max_features': ['auto', 'sqrt', 'log2'],
                   'randomforestregressor__max_depth': [None, 5, 3, 1]}

max_features - określa maksymalną liczbę funkcji do rozważenia podczas szukania podziału.

Mamy tu 3 metody: ['auto', 'sqrt', 'log2'] i program sam wybierze najlepszą metodę dostrojenia.

max_features:"auto" żaden podzbiór cech nie jest wykonywany na drzewach, więc „losowy las” jest właściwie zapakowanym zespołem zwykłych drzew regresji. Przy ustawieniu AUTO, kod weźmie wszystkie funkcje, które mają sens z każdego drzewie. Tutaj nie są nakładane żadnych ograniczenia na pojedyncze drzewa.

max_features: „sqrt”, Ta opcja pobierająca pierwiastek kwadratowy z całkowitej liczby funkcji w pojedynczym przebiegu. Na przykład, jeśli całkowita liczba zmiennych wynosi 100, możemy wziąć tylko 10 z nich w pojedynczym drzewie.

max_depth wskazuje na całkowitą głębokość drzew decyzyjnych.

Dostrajanie modelu

Kolejna linijka kodu prowadzi proces samego dostrajania algorytmu predykcji. Obiekt fit jest to funkcją dopasowującą.

from sklearn.model_selection import GridSearchCV
clf = GridSearchCV(pipeline, hyperparameters, cv=10)
clf.fit(X_train, y_train)

Powyższy kod odpowiada za dostrajanie modelu. Z wielkiej ilości interakcji kod wybiera najlepszy wariant.

Istnieją dwa sposoby szukania najlepszych hiperpartametrów do dostrojenia modelu:

1. szukanie przez siatkę (tzw. ‘Grid’)
2. szukanie losowe

GridSearchCV – to metoda siatki, nielosowa metoda dostrajania modelu.

Przypomnijmy:

W Pipeline wskazaliśmy metody transformatora: StandardScaler() i estymator: RandomForestRegressor().

Następnie w kodzie Hyperparameters – wskazaliśmy parametry: max_features oraz max_depth.

Ponieważ używamy GridSearchCV, ta funkcja decyduje o najlepszej wartości w max_features i innych zadanych hiperparametrach w zależności od tego, jak dobrze klasyfikator działa na zbiorze danych.

Teraz sprawdzamy, jakie wartość parametrów dostrajania modelu okazały się optymalne.

import pprint
pparam=pprint.PrettyPrinter(indent=2)
print(clf.best_params_)

Czas sprawdzić, na ile nasz model jest dobry, na ile trafnie opisuje rzeczywistość.

Przypomnijmy, że celem modelu było wskazanie na podstawie wyników badań czy dany pacjent jest chory na cukrzycę czy nie. Czyli odpowiedź modelu w postaci zmiennej zależnej y powinien wynosić 0 lub 1.

Niestety nasz model nie tworzy wartości dyskretnych tylko wartości ciągłe.

Zmieniamy to jedną linijką kodu.

y_pred = np.round(y_pred, decimals=0)

Ocena modelu przez Confusion Matrix

Do oceny naszego modelu tworzącego odpowiedzi binarne, użyjemy Confusion Matrix.

Macierz wskazuje na ile model trafnie typuje odpowiedzi. Zestawia się tu odpowiedzi ze zbioru testowego z odpowiedziami uzyskanymi w drodze predykcji.

from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))

Macierz ma dwa wymiary ponieważ odpowiedzi mają charakter binarny.

Jak interpretować Confusion Matrix?

Macierz wskazuje ile razy model Random Forest trafnie wytypował odpowiedź a ile razy się pomylił.

Wyobraźmy sobie, że to jest macierz Confusion Matrix.

Liczby w polach białych oznaczają ilość trafnych typowań, zaś liczby w czarnych polach oznaczają typowania błędne. Intuicyjnie będziemy lepiej oceniali modele które mają istotną przewagę w polach białych nad polami czarnymi.

Wskaźniki Confusion Matrix

 Celność modelu  (accuracy (ACC)) jest interpretowana jako dokładność klasyfikacji. Jest liczana jako suma liczb z białych pól do sumy liczb ze wszystkich pól: ACC = A+D / A+B+C+D. Czym wyższa wartość procentowa tym lepiej.

(87+20) / (87+20+13+34) = 69

 Precyzja modelu  (precision or positive predictive value (PPV)) czyli poziom sprawdzalności prognoz modelu. Jest liczona jako PPV = A / A+B.

87 / (87+13) = 87

 Odwołanie modelu  (sensitivity, recall, hit rate, or true positive rate (TPR))– w ilu przypadkach obecni pacjenci z cukrzycą  są identyfikowani przez model jako chorzy. Jest liczona jako   TPR = A / A+C.

87 / (87+34) = 72

 F-Score 

Trudno jest porównać model z niskim  Precision i wysokim przypomnieniem Recall i odwrotnie.

Aby porównać modele należy użyć F-Score, które mierzy  jednocześnie Recall i Precision.

F-Score = (2* Precision* Recall)/( Precision+ Recall) = 2A/(2A+B+C)

2*87 / (2*87 + 34 + 13) = 79

Wszystkie te obliczenia można uzyskać korzystając z następującego kodu:

print(classification_report(y_test, y_pred))

oraz

print("Accuracy: ",np.round(metrics.accuracy_score(y_test, y_pred), decimals=2))

Na końcu możemy zapamiętać model wpisując kod:

joblib.dump(clf, 'c:/1/rf_regressor.pkl')

Aby otworzyć model wystarczy wpisać:

clf2 = joblib.load('c:/1/rf_regressor.pkl')