Scikit Learn - Szybki przewodnik
W tym rozdziale zrozumiemy, czym jest Scikit-Learn lub Sklearn, pochodzenie Scikit-Learn i kilka innych powiązanych tematów, takich jak społeczności i współpracownicy odpowiedzialni za rozwój i utrzymanie Scikit-Learn, jego wymagania wstępne, instalację i funkcje.
Co to jest Scikit-Learn (Sklearn)
Scikit-learn (Sklearn) to najbardziej użyteczna i niezawodna biblioteka do uczenia maszynowego w Pythonie. Zapewnia wybór wydajnych narzędzi do uczenia maszynowego i modelowania statystycznego, w tym klasyfikacji, regresji, grupowania i redukcji wymiarowości za pośrednictwem interfejsu spójności w Pythonie. Ta biblioteka, która jest w dużej mierze napisana w Pythonie, została zbudowana na podstawieNumPy, SciPy i Matplotlib.
Pochodzenie Scikit-Learn
Pierwotnie był nazywany scikits.learn i został pierwotnie opracowany przez Davida Cournapeau jako projekt Google Summer of Code w 2007 roku. Później, w 2010 roku, Fabian Pedregosa, Gael Varoquaux, Alexandre Gramfort i Vincent Michel z FIRCA (Francuski Instytut Badań w Informatyce i Automatyzacji) ten projekt na innym poziomie i pierwsze publiczne wydanie (v0.1 beta) ukazało się 1 lutego 2010.
Rzućmy okiem na historię wersji -
Maj 2019: scikit-learn 0.21.0
Marzec 2019: scikit-learn 0.20.3
Grudzień 2018: scikit-learn 0.20.2
Listopad 2018: scikit-learn 0.20.1
Wrzesień 2018: scikit-learn 0.20.0
Lipiec 2018: scikit-learn 0.19.2
Lipiec 2017: scikit-learn 0.19.0
Wrzesień 2016 r. Scikit-learn 0.18.0
Listopad 2015. scikit-learn 0.17.0
Marzec 2015. scikit-learn 0.16.0
Lipiec 2014 r. Scikit-learn 0.15.0
Sierpień 2013. scikit-learn 0.14
Społeczność i współtwórcy
Scikit-learn to wysiłek społeczności i każdy może się do niego przyczynić. Ten projekt jest hostowanyhttps://github.com/scikit-learn/scikit-learn. Następujące osoby są obecnie głównymi współpracownikami w rozwoju i utrzymaniu Sklearn -
Joris Van den Bossche (analityk danych)
Thomas J Fan (programista)
Alexandre Gramfort (badacz uczenia maszynowego)
Olivier Grisel (ekspert ds. Uczenia maszynowego)
Nicolas Hug (współpracownik naukowy)
Andreas Mueller (naukowiec ds. Uczenia maszynowego)
Hanmin Qin (inżynier oprogramowania)
Adrin Jalali (programista Open Source)
Nelle Varoquaux (badaczka danych)
Roman Yurchak (analityk danych)
Różne organizacje, takie jak Booking.com, JP Morgan, Evernote, Inria, AWeber, Spotify i wiele innych, używają Sklearn.
Wymagania wstępne
Zanim zaczniemy korzystać z najnowszej wersji scikit-learn, potrzebujemy:
Python (> = 3,5)
NumPy (> = 1.11.0)
Scipy (> = 0,17,0) li
Joblib (> = 0,11)
Matplotlib (> = 1.5.1) jest wymagany do drukowania w Sklearn.
Pandy (> = 0.18.0) jest wymagane w przypadku niektórych przykładów scikit-learning wykorzystujących strukturę danych i analizę.
Instalacja
Jeśli już zainstalowałeś NumPy i Scipy, oto dwa najłatwiejsze sposoby instalacji scikit-learn -
Korzystanie z pip
Następujące polecenie może być użyte do zainstalowania scikit-learn przez pip -
pip install -U scikit-learnKorzystanie z conda
Następujące polecenie może być użyte do zainstalowania scikit-learn przez conda -
conda install scikit-learnZ drugiej strony, jeśli NumPy i Scipy nie są jeszcze zainstalowane na Twojej stacji roboczej Python, możesz je zainstalować za pomocą pip lub conda.
Inną opcją użycia scikit-learn jest użycie dystrybucji Pythona, takich jak Canopy i Anaconda ponieważ obaj dostarczają najnowszą wersję scikit-learn.
funkcje
Zamiast skupiać się na ładowaniu, manipulowaniu i podsumowywaniu danych, biblioteka Scikit-learn skupia się na modelowaniu danych. Niektóre z najpopularniejszych grup modeli dostarczanych przez Sklearn to:
Supervised Learning algorithms - Prawie wszystkie popularne algorytmy uczenia nadzorowanego, takie jak regresja liniowa, maszyna wektorów nośnych (SVM), drzewo decyzyjne itp., Są częścią scikit-learn.
Unsupervised Learning algorithms - Z drugiej strony ma również wszystkie popularne algorytmy uczenia się bez nadzoru, od grupowania, analizy czynnikowej, PCA (Principal Component Analysis) po nienadzorowane sieci neuronowe.
Clustering - Ten model służy do grupowania danych bez etykiet.
Cross Validation - Służy do sprawdzania poprawności nadzorowanych modeli na niewidocznych danych.
Dimensionality Reduction - Służy do zmniejszania liczby atrybutów w danych, które można później wykorzystać do podsumowania, wizualizacji i wyboru cech.
Ensemble methods - Jak nazwa sugeruje, jest używany do łączenia prognoz wielu nadzorowanych modeli.
Feature extraction - Służy do wyodrębniania cech z danych w celu zdefiniowania atrybutów w danych obrazu i tekstu.
Feature selection - Służy do identyfikacji przydatnych atrybutów do tworzenia nadzorowanych modeli.
Open Source - Jest to biblioteka o otwartym kodzie źródłowym, a także do użytku komercyjnego na licencji BSD.
Ten rozdział dotyczy procesu modelowania związanego ze Sklearn. Rozumiemy szczegółowo to samo i zacznijmy od załadowania zbioru danych.
Ładowanie zestawu danych
Zbiór danych nosi nazwę zbioru danych. Składa się z dwóch następujących elementów -
Features- Zmienne danych nazywane są jego cechami. Są również znane jako predyktory, dane wejściowe lub atrybuty.
Feature matrix - To zbiór funkcji, na wypadek gdyby było ich więcej niż jedna.
Feature Names - To jest lista wszystkich nazw funkcji.
Response- Jest to zmienna wyjściowa, która zasadniczo zależy od zmiennych cech. Są również znane jako cel, etykieta lub wynik.
Response Vector- Służy do reprezentowania kolumny odpowiedzi. Ogólnie mamy tylko jedną kolumnę odpowiedzi.
Target Names - Reprezentuje możliwe wartości przyjęte przez wektor odpowiedzi.
Scikit-learn ma kilka przykładowych zestawów danych, takich jak iris i digits do klasyfikacji i Boston house prices do regresji.
Przykład
Poniżej znajduje się przykład do załadowania iris zbiór danych -
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names
print("Feature names:", feature_names)
print("Target names:", target_names)
print("\nFirst 10 rows of X:\n", X[:10])Wynik
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names: ['setosa' 'versicolor' 'virginica']
First 10 rows of X:
[
[5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]
[4.7 3.2 1.3 0.2]
[4.6 3.1 1.5 0.2]
[5. 3.6 1.4 0.2]
[5.4 3.9 1.7 0.4]
[4.6 3.4 1.4 0.3]
[5. 3.4 1.5 0.2]
[4.4 2.9 1.4 0.2]
[4.9 3.1 1.5 0.1]
]Dzielenie zbioru danych
Aby sprawdzić dokładność naszego modelu, możemy podzielić zbiór danych na dwie części:a training set i a testing set. Użyj zestawu uczącego, aby wytrenować model i zestaw testowy, aby przetestować model. Następnie możemy ocenić, jak dobrze poradził sobie nasz model.
Przykład
Poniższy przykład podzieli dane na stosunek 70:30, tj. 70% danych zostanie wykorzystanych jako dane treningowe, a 30% jako dane testowe. Zbiór danych to zbiór danych tęczówki, jak w powyższym przykładzie.
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size = 0.3, random_state = 1
)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)Wynik
(105, 4)
(45, 4)
(105,)
(45,)Jak widać w powyższym przykładzie, używa train_test_split()funkcja scikit-learn do dzielenia zbioru danych. Ta funkcja ma następujące argumenty -
X, y - Tutaj, X jest feature matrix a y to response vector, które należy podzielić.
test_size- Przedstawia stosunek danych testowych do wszystkich podanych danych. Jak w powyższym przykładzie ustawiamytest_data = 0.3 dla 150 rzędów X. Wytworzy dane testowe 150 * 0,3 = 45 rzędów.
random_size- Służy do zagwarantowania, że podział będzie zawsze taki sam. Jest to przydatne w sytuacjach, w których chcesz uzyskać powtarzalne wyniki.
Trenuj model
Następnie możemy użyć naszego zestawu danych, aby wytrenować model predykcyjny. Jak już wspomniano, scikit-learn ma szeroki zakresMachine Learning (ML) algorithms które mają spójny interfejs do dopasowania, przewidywania dokładności, przypominania itp.
Przykład
W poniższym przykładzie użyjemy klasyfikatora KNN (K najbliższych sąsiadów). Nie wchodź w szczegóły algorytmów KNN, ponieważ będzie to osobny rozdział. Ten przykład służy wyłącznie do zrozumienia części dotyczącej implementacji.
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size = 0.4, random_state=1
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
classifier_knn = KNeighborsClassifier(n_neighbors = 3)
classifier_knn.fit(X_train, y_train)
y_pred = classifier_knn.predict(X_test)
# Finding accuracy by comparing actual response values(y_test)with predicted response value(y_pred)
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
# Providing sample data and the model will make prediction out of that data
sample = [[5, 5, 3, 2], [2, 4, 3, 5]]
preds = classifier_knn.predict(sample)
pred_species = [iris.target_names[p] for p in preds] print("Predictions:", pred_species)Wynik
Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']Trwałość modelu
Po wytrenowaniu modelu pożądane jest, aby został on utrwalony do wykorzystania w przyszłości, aby nie trzeba było go ponownie uczyć. Można to zrobić za pomocądump i load cechy joblib pakiet.
Rozważ poniższy przykład, w którym będziemy zapisywać powyższy wyuczony model (classifier_knn) do wykorzystania w przyszłości -
from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')Powyższy kod zapisze model do pliku o nazwie iris_classifier_knn.joblib. Teraz obiekt można przeładować z pliku za pomocą następującego kodu -
joblib.load('iris_classifier_knn.joblib')Wstępne przetwarzanie danych
Ponieważ mamy do czynienia z dużą ilością danych, a dane są w postaci surowej, przed wprowadzeniem tych danych do algorytmów uczenia maszynowego musimy je przekształcić w znaczące dane. Ten proces nazywa się przetwarzaniem wstępnym danych. Scikit-learn ma pakiet o nazwiepreprocessingw tym celu. Plikpreprocessing pakiet ma następujące techniki -
Binaryzacja
Ta technika przetwarzania wstępnego jest używana, gdy musimy przekonwertować nasze wartości liczbowe na wartości logiczne.
Przykład
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]]
)
data_binarized = preprocessing.Binarizer(threshold=0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)W powyższym przykładzie użyliśmy threshold value = 0,5 i dlatego wszystkie wartości powyżej 0,5 zostaną zamienione na 1, a wszystkie wartości poniżej 0,5 zostaną zamienione na 0.
Wynik
Binarized data:
[
[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]
]Średnie usuwanie
Technika ta służy do eliminacji średniej z wektora cech, tak aby każda cecha była wyśrodkowana na zero.
Przykład
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]]
)
#displaying the mean and the standard deviation of the input data
print("Mean =", input_data.mean(axis=0))
print("Stddeviation = ", input_data.std(axis=0))
#Removing the mean and the standard deviation of the input data
data_scaled = preprocessing.scale(input_data)
print("Mean_removed =", data_scaled.mean(axis=0))
print("Stddeviation_removed =", data_scaled.std(axis=0))Wynik
Mean = [ 1.75 -1.275 2.2 ]
Stddeviation = [ 2.71431391 4.20022321 4.69414529]
Mean_removed = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Stddeviation_removed = [ 1. 1. 1.]skalowanie
Używamy tej techniki przetwarzania wstępnego do skalowania wektorów cech. Skalowanie wektorów cech jest ważne, ponieważ cechy nie powinny być syntetycznie duże ani małe.
Przykład
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)Wynik
Min max scaled data:
[
[ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0.99029126 0. ]
]Normalizacja
Używamy tej techniki przetwarzania wstępnego do modyfikowania wektorów cech. Normalizacja wektorów cech jest konieczna, aby wektory cech można było mierzyć we wspólnej skali. Istnieją dwa rodzaje normalizacji w następujący sposób -
Normalizacja L1
Nazywa się to również najmniejszymi odchyleniami bezwzględnymi. Modyfikuje wartość w taki sposób, że suma wartości bezwzględnych pozostaje zawsze do 1 w każdym wierszu. Poniższy przykład pokazuje implementację normalizacji L1 na danych wejściowych.
Przykład
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_normalized_l1 = preprocessing.normalize(input_data, norm='l1')
print("\nL1 normalized data:\n", data_normalized_l1)Wynik
L1 normalized data:
[
[ 0.22105263 -0.2 0.57894737]
[-0.2027027 0.32432432 0.47297297]
[ 0.03571429 -0.56428571 0.4 ]
[ 0.42142857 0.16428571 -0.41428571]
]Normalizacja L2
Nazywany również najmniejszymi kwadratami. Modyfikuje wartość w taki sposób, że suma kwadratów pozostaje zawsze do 1 w każdym wierszu. Poniższy przykład pokazuje implementację normalizacji L2 na danych wejściowych.
Przykład
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_normalized_l2 = preprocessing.normalize(input_data, norm='l2')
print("\nL1 normalized data:\n", data_normalized_l2)Wynik
L2 normalized data:
[
[ 0.33946114 -0.30713151 0.88906489]
[-0.33325106 0.53320169 0.7775858 ]
[ 0.05156558 -0.81473612 0.57753446]
[ 0.68706914 0.26784051 -0.6754239 ]
]Jak wiemy, uczenie maszynowe ma zamiar stworzyć model z danych. W tym celu komputer musi najpierw zrozumieć dane. Następnie omówimy różne sposoby przedstawiania danych w celu ich zrozumienia przez komputer -
Dane w formie tabeli
Najlepszym sposobem reprezentacji danych w Scikit-learn są tabele. Tabela reprezentuje dwuwymiarową siatkę danych, w której wiersze reprezentują poszczególne elementy zbioru danych, a kolumny reprezentują wielkości związane z tymi pojedynczymi elementami.
Przykład
Z poniższego przykładu możemy pobrać iris dataset w formie Pandas DataFrame przy pomocy Pythona seaborn biblioteka.
import seaborn as sns
iris = sns.load_dataset('iris')
iris.head()Wynik
sepal_length sepal_width petal_length petal_width species
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
3 4.6 3.1 1.5 0.2 setosa
4 5.0 3.6 1.4 0.2 setosaZ powyższych wyników widać, że każdy wiersz danych reprezentuje pojedynczy obserwowany kwiat, a liczba rzędów reprezentuje całkowitą liczbę kwiatów w zbiorze danych. Zazwyczaj wiersze macierzy nazywamy próbkami.
Z drugiej strony każda kolumna danych przedstawia informacje ilościowe opisujące każdą próbkę. Generalnie kolumny macierzy nazywamy cechami.
Dane jako macierz funkcji
Macierz funkcji można zdefiniować jako układ tabeli, w którym informacje można traktować jako macierz 2D. Jest przechowywany w zmiennej o nazwieXi założono, że jest dwuwymiarowy i ma kształt [n_samples, n_features]. Przeważnie jest zawarty w tablicy NumPy lub Pandas DataFrame. Jak powiedziano wcześniej, próbki zawsze reprezentują indywidualne obiekty opisane przez zbiór danych, a cechy reprezentują odrębne obserwacje, które opisują każdą próbkę w sposób ilościowy.
Dane jako tablica docelowa
Wraz z macierzą cech, oznaczoną X, mamy również tablicę docelową. Nazywa się to również etykietą. Jest oznaczony przez y. Tablica etykiety lub celu jest zwykle jednowymiarowa i ma długość n_samples. Zwykle jest zawarty w NumPyarray lub Pandy Series. Tablica docelowa może mieć zarówno wartości, ciągłe wartości liczbowe, jak i wartości dyskretne.
Czym tablica docelowa różni się od kolumn funkcji?
Możemy rozróżnić jednym punktem, że tablica docelowa jest zwykle wielkością, którą chcemy przewidzieć z danych, czyli w kategoriach statystycznych jest to zmienna zależna.
Przykład
W poniższym przykładzie, na podstawie zbioru danych tęczówki, przewidujemy gatunek kwiatu na podstawie innych pomiarów. W takim przypadku kolumna Gatunek byłaby uznawana za cechę.
import seaborn as sns
iris = sns.load_dataset('iris')
%matplotlib inline
import seaborn as sns; sns.set()
sns.pairplot(iris, hue='species', height=3);Wynik
X_iris = iris.drop('species', axis=1)
X_iris.shape
y_iris = iris['species']
y_iris.shapeWynik
(150,4)
(150,)W tym rozdziale dowiemy się o tym Estimator API(Interfejs aplikacji do programowania). Zacznijmy od zrozumienia, czym jest Estimator API.
Co to jest Estimator API
Jest to jeden z głównych interfejsów API wdrożonych przez Scikit-learn. Zapewnia spójny interfejs dla szerokiej gamy aplikacji ML, dlatego wszystkie algorytmy uczenia maszynowego w Scikit-Learn są implementowane za pośrednictwem Estimator API. Obiekt, który uczy się na podstawie danych (dopasowywanie danych) jest estymatorem. Może być używany z dowolnym algorytmem, takim jak klasyfikacja, regresja, grupowanie, a nawet z transformatorem, który wyodrębnia przydatne funkcje z surowych danych.
Aby dopasować dane, wszystkie obiekty estymatora udostępniają metodę dopasowania, która przyjmuje zestaw danych pokazany w następujący sposób -
estimator.fit(data)Następnie wszystkie parametry estymatora można ustawić w następujący sposób, gdy jest on tworzony przez odpowiedni atrybut.
estimator = Estimator (param1=1, param2=2)
estimator.param1Wynik powyższego będzie 1.
Po wyposażeniu danych w estymator parametry są szacowane na podstawie dostępnych danych. Teraz wszystkie oszacowane parametry będą atrybutami obiektu estymatora zakończonymi podkreśleniem w następujący sposób -
estimator.estimated_param_Korzystanie z Estimator API
Główne zastosowania estymatorów są następujące -
Estymacja i dekodowanie modelu
Obiekt estymatora służy do estymacji i dekodowania modelu. Ponadto model jest szacowany jako deterministyczna funkcja:
Parametry, które są dostarczane w konstrukcji obiektu.
Globalny stan losowy (numpy.random), jeśli parametr random_state estymatora jest ustawiony na none.
Wszelkie dane przekazane do ostatniego połączenia do fit, fit_transform, or fit_predict.
Wszelkie dane przekazane w sekwencji wywołań partial_fit.
Mapowanie nieprostokątnej reprezentacji danych na dane prostokątne
Mapuje nieprostokątną reprezentację danych na dane prostokątne. Mówiąc prościej, pobiera dane wejściowe, w których każda próbka nie jest reprezentowana jako obiekt podobny do tablicy o ustalonej długości, i tworzy obiekt podobny do tablicy z cechami dla każdej próbki.
Rozróżnienie między próbkami podstawowymi i zewnętrznymi
Modeluje rozróżnienie między próbkami rdzeniowymi i zewnętrznymi przy użyciu następujących metod:
fit
fit_predict if transductive
przewidzieć, czy indukcyjne
Zasady przewodnie
Projektując API Scikit-Learn, należy pamiętać o głównych zasadach -
Konsystencja
Zasada ta mówi, że wszystkie obiekty powinny mieć wspólny interfejs wyrysowany z ograniczonego zestawu metod. Dokumentacja powinna być również spójna.
Ograniczona hierarchia obiektów
Ta naczelna zasada mówi:
Algorytmy powinny być reprezentowane przez klasy Pythona
Zestawy danych powinny być reprezentowane w standardowym formacie, takim jak tablice NumPy, Pandas DataFrames, SciPy sparse matrix.
Nazwy parametrów powinny używać standardowych łańcuchów Pythona.
Kompozycja
Jak wiemy, algorytmy ML można wyrazić jako sekwencję wielu podstawowych algorytmów. Scikit-learn wykorzystuje te podstawowe algorytmy zawsze, gdy jest to potrzebne.
Rozsądne wartości domyślne
Zgodnie z tą zasadą biblioteka Scikit-learn definiuje odpowiednią wartość domyślną, gdy modele ML wymagają parametrów określonych przez użytkownika.
Kontrola
Zgodnie z tą zasadą przewodnią każda określona wartość parametru jest ujawniana jako atrybuty publiczne.
Kroki korzystania z Estimator API
Poniżej przedstawiono kroki korzystania z interfejsu API estymatora Scikit-Learn -
Krok 1: Wybierz klasę modelu
W tym pierwszym kroku musimy wybrać klasę modelu. Można to zrobić, importując odpowiednią klasę estymatora ze Scikit-learn.
Krok 2: Wybierz hiperparametry modelu
W tym kroku musimy wybrać hiperparametry modelu klasy. Można to zrobić, tworząc instancję klasy z żądanymi wartościami.
Krok 3: Porządkowanie danych
Następnie musimy uporządkować dane w macierz cech (X) i wektor docelowy (y).
Krok 4: Dopasowanie modelu
Teraz musimy dopasować model do Twoich danych. Można to zrobić poprzez wywołanie metody fit () instancji modelu.
Krok 5: Zastosowanie modelu
Po dopasowaniu modelu możemy zastosować go do nowych danych. Do nauki nadzorowanej użyjpredict()metoda przewidywania etykiet dla nieznanych danych. Podczas uczenia się bez nadzoru użyjpredict() lub transform() wywnioskować właściwości danych.
Przykład nadzorowanej nauki
Jako przykład tego procesu bierzemy częsty przypadek dopasowania linii do danych (x, y) tj simple linear regression.
Najpierw musimy załadować zestaw danych, używamy zestawu danych tęczówki -
Przykład
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shapeWynik
(150, 4)Przykład
y_iris = iris['species']
y_iris.shapeWynik
(150,)Przykład
Teraz, dla tego przykładu regresji, użyjemy następujących przykładowych danych -
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);Wynik
Mamy więc powyższe dane dla naszego przykładu regresji liniowej.
Teraz, mając te dane, możemy zastosować powyższe kroki.
Wybierz klasę modelu
Tutaj, aby obliczyć prosty model regresji liniowej, musimy zaimportować klasę regresji liniowej w następujący sposób -
from sklearn.linear_model import LinearRegressionWybierz hiperparametry modelu
Po wybraniu klasy modelu musimy dokonać kilku ważnych wyborów, które często są przedstawiane jako hiperparametry lub parametry, które należy ustawić, zanim model zostanie dopasowany do danych. Tutaj, dla tego przykładu regresji liniowej, chcielibyśmy dopasować punkt przecięcia z osią za pomocąfit_intercept hiperparametr w następujący sposób -
Example
model = LinearRegression(fit_intercept = True)
modelOutput
LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None, normalize = False)Porządkowanie danych
Teraz, jak wiemy, nasza zmienna docelowa y ma prawidłową formę, tj. długość n_samplestablica 1-D. Ale musimy zmienić kształt macierzy cechX aby była to matryca rozmiaru [n_samples, n_features]. Można to zrobić w następujący sposób -
Example
X = x[:, np.newaxis]
X.shapeOutput
(40, 1)Dopasowanie modelu
Kiedy już uporządkujemy dane, pora dopasować model, czyli zastosować nasz model do danych. Można to zrobić za pomocąfit() metoda w następujący sposób -
Example
model.fit(X, y)Output
LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None,normalize = False)W Scikit-learn fit() proces ma kilka podkreśleń na końcu.
W tym przykładzie poniższy parametr pokazuje nachylenie prostego liniowego dopasowania danych -
Example
model.coef_Output
array([1.99839352])Poniższy parametr reprezentuje punkt przecięcia z prostym liniowym dopasowaniem do danych -
Example
model.intercept_Output
-0.9895459457775022Zastosowanie modelu do nowych danych
Po wytrenowaniu modelu możemy zastosować go do nowych danych. Ponieważ głównym zadaniem nadzorowanego uczenia maszynowego jest ocena modelu na podstawie nowych danych, które nie są częścią zbioru uczącego. Można to zrobić za pomocąpredict() metoda w następujący sposób -
Example
xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);Output
Kompletny przykład roboczy / wykonywalny
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.linear_model import LinearRegression
model = LinearRegression(fit_intercept=True)
model
X = x[:, np.newaxis]
X.shape
model.fit(X, y)
model.coef_
model.intercept_
xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);Przykład uczenia się bez nadzoru
Tutaj, jako przykład tego procesu, bierzemy powszechny przypadek zmniejszenia wymiarowości zbioru danych Iris, abyśmy mogli go łatwiej wizualizować. W tym przykładzie użyjemy analizy głównych składowych (PCA), techniki szybkiej liniowej redukcji wymiarowości.
Podobnie jak w powyższym przykładzie, możemy załadować i wykreślić losowe dane z zestawu danych tęczówki. Następnie możemy wykonać poniższe czynności -
Wybierz klasę modelu
from sklearn.decomposition import PCAWybierz hiperparametry modelu
Example
model = PCA(n_components=2)
modelOutput
PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
svd_solver = 'auto', tol = 0.0, whiten = False)Dopasowanie modelu
Example
model.fit(X_iris)Output
PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
svd_solver = 'auto', tol = 0.0, whiten = False)Przekształć dane w dwuwymiarowe
Example
X_2D = model.transform(X_iris)Teraz możemy wykreślić wynik w następujący sposób -
Output
iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue = 'species', data = iris, fit_reg = False);Output
Kompletny przykład roboczy / wykonywalny
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.decomposition import PCA
model = PCA(n_components=2)
model
model.fit(X_iris)
X_2D = model.transform(X_iris)
iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue='species', data=iris, fit_reg=False);Obiekty Scikit-learn współużytkują jednolity podstawowy interfejs API, który składa się z trzech uzupełniających się interfejsów -
Estimator interface - Służy do budowania i dopasowywania modeli.
Predictor interface - Służy do przewidywania.
Transformer interface - Służy do konwersji danych.
Interfejsy API przyjmują proste konwencje, a wybory projektowe są kierowane w sposób zapobiegający rozprzestrzenianiu się kodu platformy.
Cel konwencji
Celem konwencji jest upewnienie się, że API przestrzega następujących ogólnych zasad -
Consistency - Wszystkie obiekty, czy to podstawowe, czy złożone, muszą mieć wspólny interfejs, który dodatkowo składa się z ograniczonego zestawu metod.
Inspection - Parametry konstruktora i wartości parametrów określone przez algorytm uczący się powinny być przechowywane i ujawniane jako atrybuty publiczne.
Non-proliferation of classes - Zestawy danych powinny być reprezentowane jako tablice NumPy lub macierze rzadkie Scipy, podczas gdy nazwy i wartości hiperparametrów powinny być reprezentowane jako standardowe ciągi znaków Pythona, aby uniknąć mnożenia się kodu platformy.
Composition - Algorytmy, niezależnie od tego, czy można je wyrazić jako sekwencje, czy też kombinacje przekształceń danych, czy też naturalnie postrzegane jako meta-algorytmy sparametryzowane w innych algorytmach, powinny zostać wdrożone i złożone z istniejących bloków konstrukcyjnych.
Sensible defaults- W scikit-learn ilekroć operacja wymaga parametru zdefiniowanego przez użytkownika, definiowana jest odpowiednia wartość domyślna. Ta wartość domyślna powinna spowodować, że operacja zostanie wykonana w rozsądny sposób, na przykład podając rozwiązanie bazowe dla wykonywanego zadania.
Różne konwencje
Konwencje dostępne w Sklearn są wyjaśnione poniżej -
Rzutowanie typów
Stwierdza, że wejście powinno być rzutowane float64. W poniższym przykładzie, w którymsklearn.random_projection moduł służący do zmniejszenia wymiarowości danych, wyjaśni to -
Example
import numpy as np
from sklearn import random_projection
rannge = np.random.RandomState(0)
X = range.rand(10,2000)
X = np.array(X, dtype = 'float32')
X.dtype
Transformer_data = random_projection.GaussianRandomProjection()
X_new = transformer.fit_transform(X)
X_new.dtypeOutput
dtype('float32')
dtype('float64')W powyższym przykładzie widzimy, że X to float32 do którego jest rzucany float64 przez fit_transform(X).
Dopasowanie i aktualizacja parametrów
Hiperparametry estymatora można aktualizować i ponownie instalować po jego skonstruowaniu za pomocą set_params()metoda. Zobaczmy następujący przykład, aby to zrozumieć -
Example
import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC
X, y = load_iris(return_X_y = True)
clf = SVC()
clf.set_params(kernel = 'linear').fit(X, y)
clf.predict(X[:5])Output
array([0, 0, 0, 0, 0])Po skonstruowaniu estymatora powyższy kod zmieni domyślne jądro rbf do linear przez SVC.set_params().
Teraz poniższy kod zmieni jądro z powrotem na rbf, aby ponownie dopasować estymator i wykonać drugą prognozę.
Example
clf.set_params(kernel = 'rbf', gamma = 'scale').fit(X, y)
clf.predict(X[:5])Output
array([0, 0, 0, 0, 0])Kompletny kod
Poniżej znajduje się kompletny program wykonywalny -
import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC
X, y = load_iris(return_X_y = True)
clf = SVC()
clf.set_params(kernel = 'linear').fit(X, y)
clf.predict(X[:5])
clf.set_params(kernel = 'rbf', gamma = 'scale').fit(X, y)
clf.predict(X[:5])Okucie wieloklasowe i Multilabel
W przypadku dopasowania wieloklasowego zarówno uczenie się, jak i zadania predykcyjne zależą od formatu dopasowanych danych docelowych. Zastosowany moduł tosklearn.multiclass. Sprawdź poniższy przykład, w którym klasyfikator wieloklasowy pasuje do tablicy 1d.
Example
from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
X = [[1, 2], [3, 4], [4, 5], [5, 2], [1, 1]]
y = [0, 0, 1, 1, 2]
classif = OneVsRestClassifier(estimator = SVC(gamma = 'scale',random_state = 0))
classif.fit(X, y).predict(X)Output
array([0, 0, 1, 1, 2])W powyższym przykładzie klasyfikator pasuje do jednowymiarowej tablicy etykiet wieloklasowych i predict()metoda zapewnia zatem odpowiednie przewidywanie wieloklasowe. Ale z drugiej strony możliwe jest również dopasowanie do dwuwymiarowej tablicy binarnych wskaźników etykiet w następujący sposób -
Example
from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
X = [[1, 2], [3, 4], [4, 5], [5, 2], [1, 1]]
y = LabelBinarizer().fit_transform(y)
classif.fit(X, y).predict(X)Output
array(
[
[0, 0, 0],
[0, 0, 0],
[0, 1, 0],
[0, 1, 0],
[0, 0, 0]
]
)Podobnie, w przypadku dopasowania wielu etykiet, do wystąpienia można przypisać wiele etykiet w następujący sposób -
Example
from sklearn.preprocessing import MultiLabelBinarizer
y = [[0, 1], [0, 2], [1, 3], [0, 2, 3], [2, 4]]
y = MultiLabelBinarizer().fit_transform(y)
classif.fit(X, y).predict(X)Output
array(
[
[1, 0, 1, 0, 0],
[1, 0, 1, 0, 0],
[1, 0, 1, 1, 0],
[1, 0, 1, 1, 0],
[1, 0, 1, 0, 0]
]
)W powyższym przykładzie sklearn.MultiLabelBinarizersłuży do binaryzacji dwuwymiarowej tablicy multilabel, do której pasują. Dlatego funkcja Predict () podaje jako dane wyjściowe tablicę 2d z wieloma etykietami dla każdej instancji.
Ten rozdział pomoże ci w nauce modelowania liniowego w Scikit-Learn. Zacznijmy od zrozumienia, czym jest regresja liniowa w Sklearn.
W poniższej tabeli wymieniono różne modele liniowe dostarczone przez Scikit-Learn -
| Sr.No | Opis modelu |
|---|---|
| 1 | Regresja liniowa Jest to jeden z najlepszych modeli statystycznych badający zależność między zmienną zależną (Y) a danym zestawem zmiennych niezależnych (X). |
| 2 | Regresja logistyczna Regresja logistyczna, pomimo swojej nazwy, jest raczej algorytmem klasyfikacji niż algorytmem regresji. Na podstawie danego zestawu zmiennych niezależnych służy do estymacji wartości dyskretnej (0 lub 1, tak / nie, prawda / fałsz). |
| 3 | Regresja grzbietu Regresja grzbietowa lub regularyzacja Tichonowa to technika regularyzacyjna, która wykonuje regularyzację L2. Modyfikuje funkcję straty, dodając karę (wielkość skurczu) równoważną do kwadratu wielkości współczynników. |
| 4 | Regresja Bayesian Ridge Regresja bayesowska pozwala naturalnemu mechanizmowi przetrwać niewystarczające dane lub słabo rozłożone dane poprzez sformułowanie regresji liniowej przy użyciu dystrybutorów prawdopodobieństwa, a nie oszacowań punktowych. |
| 5 | LASSO LASSO to technika regularyzacji, która wykonuje regularyzację L1. Modyfikuje funkcję straty, dodając karę (wielkość skurczu) równoważną zsumowaniu bezwzględnej wartości współczynników. |
| 6 | Wielozadaniowe LASSO Pozwala to dopasować problemy regresji wielorakiej, jednocześnie wymuszając, aby wybrane cechy były takie same dla wszystkich problemów regresji, zwanych także zadaniami. Sklearn dostarcza model liniowy o nazwie MultiTaskLasso, wyszkolony z mieszaną normą L1, L2 dla regularyzacji, który łącznie szacuje rzadkie współczynniki dla problemów regresji wielorakiej. |
| 7 | Elastyczna siatka Elastic-Net jest regularyzowaną metodą regresji, która liniowo łączy obie kary, tj. L1 i L2 metod regresji Lasso i Ridge. Jest to przydatne, gdy istnieje wiele skorelowanych funkcji. |
| 8 | Wielozadaniowy Elastic-Net Jest to model Elastic-Net, który pozwala dopasować wiele problemów regresji łącznie wymuszając, aby wybrane cechy były takie same dla wszystkich problemów regresji, zwanych także zadaniami |
Ten rozdział koncentruje się na elementach wielomianowych i narzędziach do tworzenia potoków w Sklearn.
Wprowadzenie do funkcji wielomianowych
Modele liniowe wytrenowane na nieliniowych funkcjach danych na ogół zapewniają szybkie działanie metod liniowych. Pozwala im również dopasować znacznie szerszy zakres danych. Z tego powodu w uczeniu maszynowym używane są takie modele liniowe, które są uczone na funkcjach nieliniowych.
Jednym z takich przykładów jest to, że prostą regresję liniową można rozszerzyć, konstruując cechy wielomianowe ze współczynników.
Matematycznie załóżmy, że mamy standardowy model regresji liniowej, a dla danych 2-D wyglądałoby to tak:
$$Y=W_{0}+W_{1}X_{1}+W_{2}X_{2}$$Teraz możemy łączyć cechy w wielomiany drugiego rzędu, a nasz model będzie wyglądał następująco -
$$Y=W_{0}+W_{1}X_{1}+W_{2}X_{2}+W_{3}X_{1}X_{2}+W_{4}X_1^2+W_{5}X_2^2$$Powyższe jest nadal modelem liniowym. Tutaj widzieliśmy, że wynikowa regresja wielomianowa należy do tej samej klasy modeli liniowych i można ją rozwiązać w podobny sposób.
Aby to zrobić, scikit-learn udostępnia moduł o nazwie PolynomialFeatures. Moduł ten przekształca macierz danych wejściowych w nową macierz danych danego stopnia.
Parametry
Poniższa tabela zawiera parametry używane przez PolynomialFeatures moduł
| Sr.No | Parametr i opis |
|---|---|
| 1 | degree - liczba całkowita, domyślnie = 2 Przedstawia stopień cech wielomianowych. |
| 2 | interaction_only - Boolean, domyślnie = false Domyślnie jest to fałsz, ale jeśli jest ustawiona jako prawda, tworzone są cechy, które są produktami o większości odrębnych cech wejściowych. Takie funkcje nazywane są funkcjami interakcji. |
| 3 | include_bias - Boolean, default = true Zawiera kolumnę odchylenia, czyli cechę, w której wszystkie potęgi wielomianów są zerowe. |
| 4 | order - str w {'C', 'F'}, domyślnie = 'C' Ten parametr reprezentuje kolejność tablicy wyjściowej w gęstym przypadku. Rząd „F” oznacza szybsze obliczenie, ale z drugiej strony może spowolnić kolejne estymatory. |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez PolynomialFeatures moduł
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | powers_ - tablica, kształt (n_output_features, n_input_features) Pokazuje, że potęgi_ [i, j] są wykładnikiem j-tego wejścia w i-tym wyjściu. |
| 2 | n_input_features _ - wew Jak sama nazwa wskazuje, podaje całkowitą liczbę funkcji wejściowych. |
| 3 | n_output_features _ - wew Jak sama nazwa wskazuje, podaje całkowitą liczbę wielomianowych cech wyjściowych. |
Przykład implementacji
Następujące użycie skryptu Pythona PolynomialFeatures transformator do przekształcenia macierzy 8 w kształt (4,2) -
from sklearn.preprocessing import PolynomialFeatures
import numpy as np
Y = np.arange(8).reshape(4, 2)
poly = PolynomialFeatures(degree=2)
poly.fit_transform(Y)Wynik
array(
[
[ 1., 0., 1., 0., 0., 1.],
[ 1., 2., 3., 4., 6., 9.],
[ 1., 4., 5., 16., 20., 25.],
[ 1., 6., 7., 36., 42., 49.]
]
)Usprawnianie przy użyciu narzędzi Pipeline
Powyższy rodzaj przetwarzania wstępnego, tj. Przekształcanie macierzy danych wejściowych w nową macierz danych danego stopnia, można usprawnić za pomocą Pipeline narzędzia, które są zasadniczo używane do łączenia wielu estymatorów w jeden.
Przykład
Poniższe skrypty Pythona używają narzędzi Pipeline firmy Scikit-learn do usprawnienia wstępnego przetwarzania (będą pasować do danych wielomianu rzędu 3).
#First, import the necessary packages.
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
import numpy as np
#Next, create an object of Pipeline tool
Stream_model = Pipeline([('poly', PolynomialFeatures(degree=3)), ('linear', LinearRegression(fit_intercept=False))])
#Provide the size of array and order of polynomial data to fit the model.
x = np.arange(5)
y = 3 - 2 * x + x ** 2 - x ** 3
Stream_model = model.fit(x[:, np.newaxis], y)
#Calculate the input polynomial coefficients.
Stream_model.named_steps['linear'].coef_Wynik
array([ 3., -2., 1., -1.])Powyższe dane wyjściowe pokazują, że model liniowy wytrenowany na cechach wielomianów jest w stanie odtworzyć dokładne współczynniki wielomianu wejściowego.
Tutaj dowiemy się o algorytmie optymalizacji w Sklearn, określanym jako Stochastic Gradient Descent (SGD).
Stochastic Gradient Descent (SGD) to prosty, ale skuteczny algorytm optymalizacji używany do znajdowania wartości parametrów / współczynników funkcji, które minimalizują funkcję kosztu. Innymi słowy, służy do dyskryminacyjnego uczenia się klasyfikatorów liniowych w wypukłych funkcjach straty, takich jak SVM i regresja logistyczna. Został on pomyślnie zastosowany do zestawów danych na dużą skalę, ponieważ aktualizacja współczynników jest wykonywana dla każdego wystąpienia szkoleniowego, a nie na końcu wystąpienia.
Klasyfikator SGD
Klasyfikator stochastycznego zejścia gradientowego (SGD) zasadniczo implementuje prostą procedurę uczenia się SGD obsługującą różne funkcje strat i kary do klasyfikacji. Scikit-learn zapewniaSGDClassifier moduł do implementacji klasyfikacji SGD.
Parametry
Poniższa tabela zawiera parametry używane przez SGDClassifier moduł -
| Sr.No | Parametr i opis |
|---|---|
| 1 | loss - str, domyślnie = 'zawias' Reprezentuje funkcję straty, która ma być używana podczas implementacji. Wartość domyślna to „zawias”, co da nam liniowy SVM. Inne opcje, których można użyć, to -
|
| 2 | penalty - str, „brak”, „l2”, „l1”, „elastyczna” Jest to termin regularyzacyjny używany w modelu. Domyślnie jest to L2. Możemy użyć L1 lub „elastycznej siatki”; ale oba mogą przynieść rzadkość w modelu, stąd nieosiągalne z L2. |
| 3 | alpha - float, domyślnie = 0.0001 Alfa, stała, która zwielokrotnia okres regularyzacji, jest parametrem strojenia, który decyduje o tym, jak bardzo chcemy ukarać model. Wartość domyślna to 0,0001. |
| 4 | l1_ratio - float, domyślnie = 0,15 Nazywa się to parametrem mieszania ElasticNet. Jego zakres wynosi 0 <= l1_ratio <= 1. Jeśli l1_ratio = 1, kara będzie wynosić L1. Jeśli l1_ratio = 0, karą byłaby kara L2. |
| 5 | fit_intercept - Boolean, Default = True Ten parametr określa, że do funkcji decyzyjnej należy dodać stałą (odchylenie lub przecięcie). W obliczeniach nie zostanie użyty żaden punkt przecięcia z osią, a dane zostaną założone już wyśrodkowane, jeśli zostanie ustawione na fałsz. |
| 6 | tol - float lub none, opcjonalnie, domyślnie = 1.e-3 Ten parametr reprezentuje kryterium zatrzymania dla iteracji. Jego domyślną wartością jest False, ale jeśli jest ustawiona na None, iteracje zatrzymają się, gdyloss > best_loss - tol for n_iter_no_changekolejne epoki. |
| 7 | shuffle - Boolean, opcjonalne, domyślnie = True Ten parametr określa, czy chcemy, aby nasze dane treningowe były tasowane po każdej epoce, czy nie. |
| 8 | verbose - liczba całkowita, domyślnie = 0 Reprezentuje poziom gadatliwości. Jego domyślna wartość to 0. |
| 9 | epsilon - float, domyślnie = 0,1 Ten parametr określa szerokość niewrażliwego regionu. Jeśli strata = „niewrażliwa na epsilon”, każda różnica między bieżącą prognozą a prawidłową etykietą, mniejsza niż próg, zostanie zignorowana. |
| 10 | max_iter - int, opcjonalne, domyślnie = 1000 Jak nazwa sugeruje, reprezentuje maksymalną liczbę przejść przez epoki, czyli dane szkoleniowe. |
| 11 | warm_start - bool, opcjonalne, domyślnie = false Z tym parametrem ustawionym na True, możemy ponownie użyć rozwiązania poprzedniego wywołania, aby dopasować się jako inicjalizacja. Jeśli wybierzemy domyślne, czyli fałszywe, usunie to poprzednie rozwiązanie. |
| 12 | random_state - int, instancja RandomState lub None, opcjonalne, default = none Ten parametr reprezentuje ziarno wygenerowanej liczby pseudolosowej, która jest używana podczas tasowania danych. Poniżej przedstawiono opcje.
|
| 13 | n_jobs - int lub none, opcjonalne, Default = None Reprezentuje liczbę procesorów, które mają być użyte w obliczeniach OVA (jeden kontra wszystkie) w przypadku problemów z wieloma klasami. Wartość domyślna to none, co oznacza 1. |
| 14 | learning_rate - ciąg, opcjonalny, domyślny = 'optymalny'
|
| 15 | eta0 - podwójne, domyślnie = 0,0 Reprezentuje początkowy współczynnik uczenia się dla wyżej wymienionych opcji współczynnika uczenia się, tj. „Stały”, „invscalling” lub „adaptacyjny”. |
| 16 | power_t - idouble, domyślnie = 0,5 Jest to wykładnik dla współczynnika uczenia się „incscalling”. |
| 17 | early_stopping - bool, default = False Ten parametr reprezentuje użycie wczesnego zatrzymania w celu zakończenia treningu, gdy wynik walidacji nie poprawia się. Jego wartość domyślna to false, ale po ustawieniu na true automatycznie odkłada stratyfikowaną część danych szkoleniowych jako walidację i zatrzymuje uczenie, gdy wynik walidacji nie poprawia się. |
| 18 | validation_fraction - float, domyślnie = 0,1 Jest używany tylko wtedy, gdy wczesne_stopowanie jest prawdziwe. Reprezentuje odsetek danych szkoleniowych, które mają zostać odłożone jako zbiór walidacyjny do wcześniejszego zakończenia danych szkoleniowych. |
| 19 | n_iter_no_change - int, domyślnie = 5 Reprezentuje liczbę iteracji bez poprawy, jeśli algorytm powinien zostać uruchomiony przed wczesnym zatrzymaniem. |
| 20 | classs_weight - dict, {class_label: weight} lub „balance”, lub None, opcjonalnie Ten parametr reprezentuje wagi skojarzone z klasami. Jeśli nie zostanie podany, klasy mają mieć wagę 1. |
| 20 | warm_start - bool, opcjonalne, domyślnie = false Z tym parametrem ustawionym na True, możemy ponownie użyć rozwiązania poprzedniego wywołania, aby dopasować się jako inicjalizacja. Jeśli wybierzemy domyślne, czyli fałszywe, usunie to poprzednie rozwiązanie. |
| 21 | average - iBoolean lub int, opcjonalnie, domyślnie = false Reprezentuje liczbę procesorów, które mają być użyte w obliczeniach OVA (jeden kontra wszystkie) w przypadku problemów z wieloma klasami. Wartość domyślna to none, co oznacza 1. |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez SGDClassifier moduł -
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | coef_ - tablica, kształt (1, n_features) if n_classes == 2, else (n_classes, n_features) Ten atrybut określa wagę przypisaną do funkcji. |
| 2 | intercept_ - tablica, kształt (1,) if n_classes == 2, else (n_classes,) Reprezentuje niezależny termin w funkcji decyzyjnej. |
| 3 | n_iter_ - wew Podaje liczbę iteracji potrzebnych do osiągnięcia kryterium zatrzymania. |
Implementation Example
Podobnie jak inne klasyfikatory, Stochastic Gradient Descent (SGD) musi być wyposażony w dwie następujące tablice -
Tablica X zawierająca próbki uczące. Ma rozmiar [n_samples, n_features].
Tablica Y zawierająca wartości docelowe, tj. Etykiety klas dla próbek uczących. Ma rozmiar [n_samples].
Example
Poniższy skrypt w Pythonie wykorzystuje model liniowy SGDClassifier -
import numpy as np
from sklearn import linear_model
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
Y = np.array([1, 1, 2, 2])
SGDClf = linear_model.SGDClassifier(max_iter = 1000, tol=1e-3,penalty = "elasticnet")
SGDClf.fit(X, Y)Output
SGDClassifier(
alpha = 0.0001, average = False, class_weight = None,
early_stopping = False, epsilon = 0.1, eta0 = 0.0, fit_intercept = True,
l1_ratio = 0.15, learning_rate = 'optimal', loss = 'hinge', max_iter = 1000,
n_iter = None, n_iter_no_change = 5, n_jobs = None, penalty = 'elasticnet',
power_t = 0.5, random_state = None, shuffle = True, tol = 0.001,
validation_fraction = 0.1, verbose = 0, warm_start = False
)Example
Teraz, po dopasowaniu, model może przewidywać nowe wartości w następujący sposób -
SGDClf.predict([[2.,2.]])Output
array([2])Example
W powyższym przykładzie możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
SGDClf.coef_Output
array([[19.54811198, 9.77200712]])Example
Podobnie możemy uzyskać wartość przechwycenia za pomocą następującego skryptu w Pythonie -
SGDClf.intercept_Output
array([10.])Example
Możemy uzyskać oznaczoną odległość do hiperpłaszczyzny za pomocą SGDClassifier.decision_function używany w następującym skrypcie w języku Python -
SGDClf.decision_function([[2., 2.]])Output
array([68.6402382])SGD Regressor
Regresor ze stochastycznym spadkiem gradientu (SGD) zasadniczo implementuje prostą procedurę uczenia się SGD obsługującą różne funkcje strat i kary w celu dopasowania modeli regresji liniowej. Scikit-learn zapewniaSGDRegressor moduł do implementacji regresji SGD.
Parametry
Parametry używane przez SGDRegressorsą prawie takie same, jak te używane w module SGDClassifier. Różnica polega na parametrze „straty”. DlaSGDRegressor parametr utraty modułów wartości dodatnie są następujące -
squared_loss - Odnosi się do zwykłego dopasowania metodą najmniejszych kwadratów.
huber: SGDRegressor- skoryguj wartości odstające, przechodząc od strat kwadratowych do liniowych po odległości epsilon. Praca „hubera” polega na zmodyfikowaniu parametru „squared_loss”, tak aby algorytm skupiał się mniej na korygowaniu wartości odstających.
epsilon_insensitive - Właściwie ignoruje błędy mniejsze niż epsilon.
squared_epsilon_insensitive- To jest to samo, co epsilon_insensitive. Jedyną różnicą jest to, że staje się to kwadratową stratą przekraczającą tolerancję epsilon.
Inną różnicą jest to, że parametr o nazwie „power_t” ma domyślną wartość 0,25 zamiast 0,5, jak w SGDClassifier. Ponadto nie ma parametrów „class_weight” i „n_jobs”.
Atrybuty
Atrybuty SGDRegressor są również takie same jak w module SGDClassifier. Ma raczej trzy dodatkowe atrybuty, jak następuje -
average_coef_ - tablica, kształt (n_features,)
Jak sama nazwa wskazuje, podaje średnie wagi przypisane cechom.
average_intercept_ - tablica, kształt (1,)
Jak sugeruje nazwa, zapewnia on uśredniony termin przechwycenia.
t_ - wew
Podaje liczbę aktualizacji wagi wykonanych podczas fazy treningu.
Note - atrybuty Average_coef_ i Average_intercept_ będą działać po ustawieniu parametru „Average” na True.
Implementation Example
Następujące użycie skryptu Pythona SGDRegressor model liniowy -
import numpy as np
from sklearn import linear_model
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
SGDReg =linear_model.SGDRegressor(
max_iter = 1000,penalty = "elasticnet",loss = 'huber',tol = 1e-3, average = True
)
SGDReg.fit(X, y)Output
SGDRegressor(
alpha = 0.0001, average = True, early_stopping = False, epsilon = 0.1,
eta0 = 0.01, fit_intercept = True, l1_ratio = 0.15,
learning_rate = 'invscaling', loss = 'huber', max_iter = 1000,
n_iter = None, n_iter_no_change = 5, penalty = 'elasticnet', power_t = 0.25,
random_state = None, shuffle = True, tol = 0.001, validation_fraction = 0.1,
verbose = 0, warm_start = False
)Example
Teraz, po dopasowaniu, możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
SGDReg.coef_Output
array([-0.00423314, 0.00362922, -0.00380136, 0.00585455, 0.00396787])Example
Podobnie możemy uzyskać wartość przechwycenia za pomocą następującego skryptu w Pythonie -
SGReg.intercept_Output
SGReg.intercept_Example
Liczbę aktualizacji wagi podczas fazy treningu możemy uzyskać za pomocą następującego skryptu w Pythonie -
SGDReg.t_Output
61.0Plusy i minusy SGD
Podążając za zaletami SGD -
Stochastic Gradient Descent (SGD) jest bardzo wydajne.
Jest bardzo łatwy do zaimplementowania, ponieważ istnieje wiele możliwości dostrajania kodu.
Zgodnie z wadami SGD -
Stochastic Gradient Descent (SGD) wymaga kilku hiperparametrów, takich jak parametry regularyzacji.
Jest wrażliwy na skalowanie cech.
W tym rozdziale omówiono metodę uczenia maszynowego określaną jako maszyny wektorów nośnych (SVM).
Wprowadzenie
Maszyny wektorów nośnych (SVM) to potężne, ale elastyczne metody nadzorowanego uczenia maszynowego wykorzystywane do klasyfikacji, regresji i wykrywania wartości odstających. SVM są bardzo wydajne w dużych przestrzeniach wymiarowych i generalnie są używane w problemach klasyfikacyjnych. Maszyny SVM są popularne i wydajne w pamięci, ponieważ wykorzystują podzbiór punktów szkoleniowych w funkcji decyzyjnej.
Głównym celem maszyn SVM jest podzielenie zbiorów danych na liczbę klas w celu znalezienia pliku maximum marginal hyperplane (MMH) co można zrobić w dwóch kolejnych krokach -
Maszyny wektorów pomocniczych będą najpierw iteracyjnie generować hiperpłaszczyzny, które w najlepszy sposób oddziela klasy.
Następnie wybierze hiperpłaszczyznę, która prawidłowo segreguje klasy.
Niektóre ważne pojęcia w SVM są następujące -
Support Vectors- Można je zdefiniować jako punkty danych, które znajdują się najbliżej hiperpłaszczyzny. Wektory pomocnicze pomagają w określeniu linii oddzielającej.
Hyperplane - Płaszczyzna decyzyjna lub przestrzeń, która dzieli zbiór obiektów o różnych klasach.
Margin - Odstęp między dwoma liniami w punktach danych szafy różnych klas nazywany jest marginesem.
Poniższe diagramy dają wgląd w te koncepcje SVM -
SVM w Scikit-learn obsługuje zarówno rzadkie, jak i gęste wektory próbek jako dane wejściowe.
Klasyfikacja SVM
Scikit-learn zapewnia trzy klasy, a mianowicie SVC, NuSVC i LinearSVC który może przeprowadzić klasyfikację wieloklasową.
SVC
Jest to klasyfikacja wektora nośnika C, na której opiera się implementacja libsvm. Moduł używany przez scikit-learn tosklearn.svm.SVC. Ta klasa obsługuje obsługę wielu klas zgodnie ze schematem jeden na jeden.
Parametry
Poniższa tabela zawiera parametry używane przez sklearn.svm.SVC klasa -
| Sr.No | Parametr i opis |
|---|---|
| 1 | C - float, opcjonalne, domyślnie = 1.0 Jest to parametr kary składnika błędu. |
| 2 | kernel - string, opcjonalny, domyślny = 'rbf' Ten parametr określa typ jądra, które ma być użyte w algorytmie. możemy wybrać dowolną spośród,‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’. Domyślna wartość jądra to‘rbf’. |
| 3 | degree - int, opcjonalne, domyślnie = 3 Reprezentuje stopień funkcji jądra „poli” i będzie ignorowany przez wszystkie inne jądra. |
| 4 | gamma - {'scale', 'auto'} lub float, Jest to współczynnik jądra dla jąder „rbf”, „poly” i „sigmoid”. |
| 5 | optinal default - = 'skala' Jeśli wybierzesz wartość domyślną, tj. Gamma = 'scale', wówczas wartość gamma, która ma być używana przez SVC, wynosi 1 / (_ ∗. ()). Z drugiej strony, jeśli gamma = 'auto', używa 1 / _. |
| 6 | coef0 - float, opcjonalne, domyślnie = 0,0 Niezależny termin w funkcji jądra, który ma znaczenie tylko w „poli” i „sigmoidzie”. |
| 7 | tol - float, opcjonalne, domyślnie = 1.e-3 Ten parametr reprezentuje kryterium zatrzymania dla iteracji. |
| 8 | shrinking - Boolean, opcjonalne, domyślnie = True Ten parametr określa, czy chcemy użyć kurczącej się heurystyki, czy nie. |
| 9 | verbose - Boolean, domyślnie: false Włącza lub wyłącza pełne informacje wyjściowe. Jego domyślna wartość to false. |
| 10 | probability - logiczna, opcjonalna, domyślna = prawda Ten parametr włącza lub wyłącza oszacowania prawdopodobieństwa. Wartość domyślna to false, ale musi być włączona przed wywołaniem fit. |
| 11 | max_iter - int, opcjonalne, domyślnie = -1 Jak sugeruje nazwa, reprezentuje maksymalną liczbę iteracji w rozwiązaniu. Wartość -1 oznacza, że nie ma ograniczenia liczby iteracji. |
| 12 | cache_size - pływak, opcjonalnie Ten parametr określa rozmiar pamięci podręcznej jądra. Wartość będzie w MB (megabajtach). |
| 13 | random_state - int, instancja RandomState lub None, opcjonalne, default = none Ten parametr reprezentuje ziarno wygenerowanej liczby pseudolosowej, która jest używana podczas tasowania danych. Poniżej znajdują się opcje -
|
| 14 | class_weight - {dict, 'balance'}, opcjonalnie Ten parametr ustawi parametr C klasy j na _ℎ [] ∗ dla SVC. Jeśli użyjemy opcji domyślnej, oznacza to, że wszystkie klasy mają mieć wagę jeden. Z drugiej strony, jeśli wybierzeszclass_weight:balanced, użyje wartości y do automatycznego dostosowania wag. |
| 15 | decision_function_shape - ovo ',' ovr ', default =' ovr ' Ten parametr zdecyduje, czy algorytm zwróci ‘ovr’ (jeden vs reszta) funkcja decyzyjna kształtu, podobnie jak wszystkie inne klasyfikatory lub oryginał ovo(jeden vs jeden) funkcja decyzyjna libsvm. |
| 16 | break_ties - boolean, opcjonalne, domyślnie = false True - Prognoza przełamie więzi zgodnie z wartościami ufności funkcji decyzyjnej False - Przewidywanie zwróci pierwszą klasę z remisujących klas. |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez sklearn.svm.SVC klasa -
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | support_ - podobny do tablicy, kształt = [n_SV] Zwraca indeksy wektorów nośnych. |
| 2 | support_vectors_ - podobny do tablicy, kształt = [n_SV, n_features] Zwraca wektory nośne. |
| 3 | n_support_ - podobne do tablicy, dtype = int32, shape = [n_class] Reprezentuje liczbę wektorów nośnych dla każdej klasy. |
| 4 | dual_coef_ - tablica, kształt = [n_class-1, n_SV] Są to współczynniki wektorów nośnych w funkcji decyzji. |
| 5 | coef_ - tablica, kształt = [n_class * (n_class-1) / 2, n_features] Ten atrybut, dostępny tylko w przypadku jądra liniowego, podaje wagę przypisaną cechom. |
| 6 | intercept_ - tablica, kształt = [n_class * (n_class-1) / 2] Reprezentuje niezależny termin (stała) w funkcji decyzyjnej. |
| 7 | fit_status_ - wew Wyjście będzie wynosić 0, jeśli zostanie prawidłowo zamontowane. Wyjście byłoby 1, jeśli jest nieprawidłowo zamontowane. |
| 8 | classes_ - tablica kształtu = [n_classes] Podaje etykiety klas. |
Implementation Example
Podobnie jak inne klasyfikatory, SVC również musi być wyposażony w następujące dwie tablice -
Tablica Xtrzymanie próbek treningowych. Ma rozmiar [n_samples, n_features].
Tablica Ytrzymanie wartości docelowych, tj. etykiet klas dla próbek uczących. Ma rozmiar [n_samples].
Następujące użycie skryptu Pythona sklearn.svm.SVC klasa -
import numpy as np
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
from sklearn.svm import SVC
SVCClf = SVC(kernel = 'linear',gamma = 'scale', shrinking = False,)
SVCClf.fit(X, y)Output
SVC(C = 1.0, cache_size = 200, class_weight = None, coef0 = 0.0,
decision_function_shape = 'ovr', degree = 3, gamma = 'scale', kernel = 'linear',
max_iter = -1, probability = False, random_state = None, shrinking = False,
tol = 0.001, verbose = False)Example
Teraz, po dopasowaniu, możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
SVCClf.coef_Output
array([[0.5, 0.5]])Example
Podobnie możemy uzyskać wartość innych atrybutów w następujący sposób -
SVCClf.predict([[-0.5,-0.8]])Output
array([1])Example
SVCClf.n_support_Output
array([1, 1])Example
SVCClf.support_vectors_Output
array(
[
[-1., -1.],
[ 1., 1.]
]
)Example
SVCClf.support_Output
array([0, 2])Example
SVCClf.intercept_Output
array([-0.])Example
SVCClf.fit_status_Output
0NuSVC
NuSVC to klasyfikacja wektorów wsparcia Nu. Jest to kolejna klasa udostępniana przez scikit-learn, która może przeprowadzić klasyfikację wieloklasową. Jest podobny do SVC, ale NuSVC akceptuje nieco inne zestawy parametrów. Parametr różniący się od SVC jest następujący -
nu - float, opcjonalne, domyślnie = 0,5
Reprezentuje górną granicę ułamka błędów uczenia i dolną granicę ułamka wektorów nośnych. Jego wartość powinna zawierać się w przedziale (o, 1].
Pozostałe parametry i atrybuty są takie same jak w SVC.
Przykład implementacji
Możemy zaimplementować ten sam przykład używając sklearn.svm.NuSVC klasa również.
import numpy as np
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
from sklearn.svm import NuSVC
NuSVCClf = NuSVC(kernel = 'linear',gamma = 'scale', shrinking = False,)
NuSVCClf.fit(X, y)Wynik
NuSVC(cache_size = 200, class_weight = None, coef0 = 0.0,
decision_function_shape = 'ovr', degree = 3, gamma = 'scale', kernel = 'linear',
max_iter = -1, nu = 0.5, probability = False, random_state = None,
shrinking = False, tol = 0.001, verbose = False)Możemy otrzymać wyniki pozostałych atrybutów, tak jak w przypadku SVC.
LinearSVC
Jest to liniowa klasyfikacja wektorów nośnych. Jest podobny do SVC, w którym kernel = 'linear'. Różnica między nimi polega na tymLinearSVC implementowany w kategoriach liblinear, podczas gdy SVC jest zaimplementowany w libsvm. To jest powódLinearSVCma większą elastyczność w wyborze kar i funkcji strat. Skaluje się również lepiej do dużej liczby próbek.
Jeśli mówimy o jego parametrach i atrybutach, to nie obsługuje ‘kernel’ ponieważ zakłada się, że jest liniowy, a także brakuje mu niektórych atrybutów, takich jak support_, support_vectors_, n_support_, fit_status_ i, dual_coef_.
Jednak obsługuje penalty i loss parametry w następujący sposób -
penalty − string, L1 or L2(default = ‘L2’)
Ten parametr służy do określenia normy (L1 lub L2) używanej w penalizacji (regularyzacji).
loss − string, hinge, squared_hinge (default = squared_hinge)
Reprezentuje funkcję straty, gdzie „zawias” to standardowa strata SVM, a „kwadratowy_zawias” to kwadrat utraty zawiasu.
Przykład implementacji
Następujące użycie skryptu Pythona sklearn.svm.LinearSVC klasa -
from sklearn.svm import LinearSVC
from sklearn.datasets import make_classification
X, y = make_classification(n_features = 4, random_state = 0)
LSVCClf = LinearSVC(dual = False, random_state = 0, penalty = 'l1',tol = 1e-5)
LSVCClf.fit(X, y)Wynik
LinearSVC(C = 1.0, class_weight = None, dual = False, fit_intercept = True,
intercept_scaling = 1, loss = 'squared_hinge', max_iter = 1000,
multi_class = 'ovr', penalty = 'l1', random_state = 0, tol = 1e-05, verbose = 0)Przykład
Teraz, po dopasowaniu, model może przewidywać nowe wartości w następujący sposób -
LSVCClf.predict([[0,0,0,0]])Wynik
[1]Przykład
W powyższym przykładzie możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
LSVCClf.coef_Wynik
[[0. 0. 0.91214955 0.22630686]]Przykład
Podobnie możemy uzyskać wartość przechwycenia za pomocą następującego skryptu w Pythonie -
LSVCClf.intercept_Wynik
[0.26860518]Regresja za pomocą SVM
Jak wspomniano wcześniej, SVM jest używana zarówno w przypadku problemów związanych z klasyfikacją, jak i regresją. Metodę klasyfikacji wektorów nośnych (SVC) opracowaną przez Scikit-learn można również rozszerzyć, aby rozwiązać problemy z regresją. Ta rozszerzona metoda nosi nazwę regresji wektora nośnego (SVR).
Podstawowe podobieństwo między SVM i SVR
Model utworzony przez SVC zależy tylko od podzbioru danych uczących. Czemu? Ponieważ funkcja kosztu budowania modelu nie dba o treningowe punkty danych, które znajdują się poza marginesem.
Podczas gdy model stworzony przez SVR (regresja wektora nośnego) również zależy tylko od podzbioru danych uczących. Czemu? Ponieważ funkcja kosztu budowania modelu ignoruje wszelkie punkty danych szkoleniowych zbliżone do prognozy modelu.
Scikit-learn zapewnia trzy klasy, a mianowicie SVR, NuSVR and LinearSVR jako trzy różne implementacje SVR.
SVR
Jest to regresja wektorowa obsługująca Epsilon, której implementacja opiera się na libsvm. W przeciwieństwie doSVC W modelu są dwa dowolne parametry, a mianowicie ‘C’ i ‘epsilon’.
epsilon - float, opcjonalne, domyślnie = 0,1
Reprezentuje epsilon w modelu epsilon-SVR i określa rurkę epsilon, w której nie jest powiązana żadna kara w funkcji utraty treningu z punktami przewidywanymi w odległości epsilon od rzeczywistej wartości.
Pozostałe parametry i atrybuty są podobne do tych, których używaliśmy w SVC.
Przykład implementacji
Następujące użycie skryptu Pythona sklearn.svm.SVR klasa -
from sklearn import svm
X = [[1, 1], [2, 2]]
y = [1, 2]
SVRReg = svm.SVR(kernel = ’linear’, gamma = ’auto’)
SVRReg.fit(X, y)Wynik
SVR(C = 1.0, cache_size = 200, coef0 = 0.0, degree = 3, epsilon = 0.1, gamma = 'auto',
kernel = 'linear', max_iter = -1, shrinking = True, tol = 0.001, verbose = False)Przykład
Teraz, po dopasowaniu, możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
SVRReg.coef_Wynik
array([[0.4, 0.4]])Przykład
Podobnie możemy uzyskać wartość innych atrybutów w następujący sposób -
SVRReg.predict([[1,1]])Wynik
array([1.1])Podobnie możemy również uzyskać wartości innych atrybutów.
NuSVR
NuSVR to regresja wektora wsparcia Nu. To jest jak NuSVC, ale NuSVR używa parametrunudo kontrolowania liczby wektorów nośnych. A ponadto, w przeciwieństwie do NuSVC, gdzienu zastąpiony parametr C, tutaj zastępuje epsilon.
Przykład implementacji
Następujące użycie skryptu Pythona sklearn.svm.SVR klasa -
from sklearn.svm import NuSVR
import numpy as np
n_samples, n_features = 20, 15
np.random.seed(0)
y = np.random.randn(n_samples)
X = np.random.randn(n_samples, n_features)
NuSVRReg = NuSVR(kernel = 'linear', gamma = 'auto',C = 1.0, nu = 0.1)^M
NuSVRReg.fit(X, y)Wynik
NuSVR(C = 1.0, cache_size = 200, coef0 = 0.0, degree = 3, gamma = 'auto',
kernel = 'linear', max_iter = -1, nu = 0.1, shrinking = True, tol = 0.001,
verbose = False)Przykład
Teraz, po dopasowaniu, możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
NuSVRReg.coef_Wynik
array(
[
[-0.14904483, 0.04596145, 0.22605216, -0.08125403, 0.06564533,
0.01104285, 0.04068767, 0.2918337 , -0.13473211, 0.36006765,
-0.2185713 , -0.31836476, -0.03048429, 0.16102126, -0.29317051]
]
)Podobnie możemy również uzyskać wartość innych atrybutów.
Liniowy SVR
Jest to liniowa regresja wektora wsparcia. Jest podobny do SVR, w którym jądro = 'linear'. Różnica między nimi polega na tymLinearSVR wdrożone pod względem liblinear, podczas gdy SVC zaimplementowano w libsvm. To jest powódLinearSVRma większą elastyczność w wyborze kar i funkcji strat. Skaluje się również lepiej do dużej liczby próbek.
Jeśli mówimy o jego parametrach i atrybutach, to nie obsługuje ‘kernel’ ponieważ zakłada się, że jest liniowy, a także brakuje mu niektórych atrybutów, takich jak support_, support_vectors_, n_support_, fit_status_ i, dual_coef_.
Obsługuje jednak następujące parametry „strat” -
loss - ciąg, opcjonalny, domyślny = 'epsilon_insensitive'
Reprezentuje funkcję straty, w której strata epsilon_insensitive to strata L1, a kwadratowa strata niewrażliwa epsilon to strata L2.
Przykład implementacji
Następujące użycie skryptu Pythona sklearn.svm.LinearSVR klasa -
from sklearn.svm import LinearSVR
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 4, random_state = 0)
LSVRReg = LinearSVR(dual = False, random_state = 0,
loss = 'squared_epsilon_insensitive',tol = 1e-5)
LSVRReg.fit(X, y)Wynik
LinearSVR(
C=1.0, dual=False, epsilon=0.0, fit_intercept=True,
intercept_scaling=1.0, loss='squared_epsilon_insensitive',
max_iter=1000, random_state=0, tol=1e-05, verbose=0
)Przykład
Teraz, po dopasowaniu, model może przewidywać nowe wartości w następujący sposób -
LSRReg.predict([[0,0,0,0]])Wynik
array([-0.01041416])Przykład
W powyższym przykładzie możemy uzyskać wektor wagi za pomocą następującego skryptu w Pythonie -
LSRReg.coef_Wynik
array([20.47354746, 34.08619401, 67.23189022, 87.47017787])Przykład
Podobnie możemy uzyskać wartość przechwycenia za pomocą następującego skryptu w Pythonie -
LSRReg.intercept_Wynik
array([-0.01041416])Tutaj dowiemy się, czym jest wykrywanie anomalii w Sklearn i jak jest wykorzystywane do identyfikacji punktów danych.
Wykrywanie anomalii to technika używana do identyfikacji punktów danych w zbiorze danych, które nie są dobrze dopasowane do reszty danych. Ma wiele zastosowań biznesowych, takich jak wykrywanie oszustw, wykrywanie włamań, monitorowanie stanu systemu, nadzór i konserwacja predykcyjna. Anomalie, nazywane również wartościami odstającymi, można podzielić na trzy kategorie:
Point anomalies - Występuje, gdy pojedyncza instancja danych jest uznawana za anomalną w odniesieniu do pozostałych danych.
Contextual anomalies- Ten rodzaj anomalii zależy od kontekstu. Występuje, gdy instancja danych jest anomalna w określonym kontekście.
Collective anomalies - Występuje, gdy zbiór powiązanych instancji danych jest anomalny w całym zestawie danych, a nie w poszczególnych wartościach.
Metody
Dwie metody, a mianowicie outlier detection i novelty detectionmoże służyć do wykrywania anomalii. Trzeba zobaczyć różnicę między nimi.
Wykrywanie wartości odstających
Dane uczące zawierają wartości odstające, które są dalekie od reszty danych. Takie wartości odstające są definiowane jako obserwacje. To jest powód, dla którego estymatory wykrywania wartości odstających zawsze starają się dopasować region, w którym znajdują się najbardziej skoncentrowane dane treningowe, ignorując obserwacje odchylenia. Jest również znany jako wykrywanie anomalii bez nadzoru.
Wykrywanie nowości
Dotyczy wykrywania nieobserwowanego wzoru w nowych obserwacjach, który nie jest uwzględniony w danych uczących. Tutaj dane szkoleniowe nie są zanieczyszczone wartościami odstającymi. Jest również znany jako częściowo nadzorowane wykrywanie anomalii.
Istnieje zestaw narzędzi ML, dostarczanych przez scikit-learn, które mogą być używane zarówno do wykrywania wartości odstających, jak i wykrywania nowości. Te narzędzia najpierw implementują uczenie się obiektów na podstawie danych w sposób nienadzorowany przy użyciu metody fit () w następujący sposób -
estimator.fit(X_train)Teraz nowe obserwacje zostaną posortowane jako inliers (labeled 1) lub outliers (labeled -1) używając metody Predict () w następujący sposób -
estimator.fit(X_test)Estymator najpierw obliczy surową funkcję oceniającą, a następnie metoda przewidywania wykorzysta próg tej surowej funkcji oceniającej. Możemy uzyskać dostęp do tej surowej funkcji punktacji za pomocąscore_sample i może kontrolować próg według contamination parametr.
Możemy też zdefiniować decision_function metoda, która definiuje wartości odstające jako wartość ujemną, a wartości wewnętrzne jako wartość nieujemną.
estimator.decision_function(X_test)Algorytmy Sklearn do wykrywania wartości odstających
Zacznijmy od zrozumienia, czym jest eliptyczna otoczka.
Dopasowanie eliptycznej koperty
Algorytm ten zakłada, że zwykłe dane pochodzą ze znanego rozkładu, takiego jak rozkład Gaussa. Do wykrywania wartości odstających Scikit-learn udostępnia obiekt o nazwiecovariance.EllipticEnvelop.
Ten obiekt dopasowuje solidne oszacowanie kowariancji do danych, a tym samym dopasowuje elipsę do centralnych punktów danych. Ignoruje punkty poza trybem centralnym.
Parametry
Poniższa tabela zawiera parametry używane przez sklearn. covariance.EllipticEnvelop metoda -
| Sr.No | Parametr i opis |
|---|---|
| 1 | store_precision - Boolean, opcjonalne, domyślnie = True Możemy to określić, jeśli przechowywana jest szacowana dokładność. |
| 2 | assume_centered - Boolean, opcjonalne, domyślnie = False Jeśli ustawimy wartość Fałsz, obliczy solidną lokalizację i kowariancję bezpośrednio za pomocą algorytmu FastMCD. Z drugiej strony, jeśli jest ustawiona na True, obliczy wsparcie niezawodnej lokalizacji i kowariancji. |
| 3 | support_fraction - float in (0., 1.), opcjonalne, domyślnie = None Ten parametr mówi metodzie, jaka proporcja punktów ma być uwzględniona w obsłudze surowych szacunków MCD. |
| 4 | contamination - float in (0, 1), opcjonalne, domyślnie = 0,1 Przedstawia odsetek wartości odstających w zbiorze danych. |
| 5 | random_state - int, instancja RandomState lub None, opcjonalne, default = none Ten parametr reprezentuje ziarno wygenerowanej liczby pseudolosowej, która jest używana podczas tasowania danych. Poniżej znajdują się opcje -
|
Atrybuty
Poniższa tabela zawiera atrybuty używane przez sklearn. covariance.EllipticEnvelop metoda -
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | support_ - tablica, kształt (n_samples,) Reprezentuje maskę obserwacji wykorzystywanych do obliczania solidnych oszacowań położenia i kształtu. |
| 2 | location_ - podobny do tablicy, kształt (n_features) Zwraca szacowaną solidną lokalizację. |
| 3 | covariance_ - podobny do tablicy, kształt (n_features, n_features) Zwraca oszacowaną solidną macierz kowariancji. |
| 4 | precision_ - podobny do tablicy, kształt (n_features, n_features) Zwraca oszacowaną macierz pseudo-odwrotną. |
| 5 | offset_ - pływak Służy do definiowania funkcji decyzyjnej na podstawie wyników surowych. decision_function = score_samples -offset_ |
Implementation Example
import numpy as np^M
from sklearn.covariance import EllipticEnvelope^M
true_cov = np.array([[.5, .6],[.6, .4]])
X = np.random.RandomState(0).multivariate_normal(mean = [0, 0], cov=true_cov,size=500)
cov = EllipticEnvelope(random_state = 0).fit(X)^M
# Now we can use predict method. It will return 1 for an inlier and -1 for an outlier.
cov.predict([[0, 0],[2, 2]])Output
array([ 1, -1])Las Izolacji
W przypadku wielowymiarowego zbioru danych jednym ze skutecznych sposobów wykrywania wartości odstających jest użycie losowych lasów. Scikit-learn zapewniaensemble.IsolationForestmetoda, która izoluje obserwacje poprzez losowy wybór cechy. Następnie losowo wybiera wartość między maksymalnymi i minimalnymi wartościami wybranych funkcji.
W tym przypadku liczba podziałów potrzebnych do wyizolowania próbki jest równa długości ścieżki od węzła głównego do węzła końcowego.
Parametry
Poniższa tabela zawiera parametry używane przez sklearn. ensemble.IsolationForest metoda -
| Sr.No | Parametr i opis |
|---|---|
| 1 | n_estimators - int, opcjonalne, domyślnie = 100 Reprezentuje liczbę podstawowych estymatorów w zespole. |
| 2 | max_samples - int lub float, opcjonalnie, domyślnie = „auto” Reprezentuje liczbę próbek, które należy pobrać z X w celu przeszkolenia każdego podstawowego estymatora. Jeśli jako wartość wybierzemy int, będzie rysował próbki max_samples. Jeśli jako wartość wybierzemy float, to narysuje on próbki max_samples ∗ .shape [0]. A jeśli wybierzemy auto jako jego wartość, to narysuje max_samples = min (256, n_samples). |
| 3 | support_fraction - float in (0., 1.), opcjonalne, domyślnie = None Ten parametr mówi metodzie, jaka proporcja punktów ma być uwzględniona w obsłudze surowych szacunków MCD. |
| 4 | contamination - auto lub float, opcjonalnie, domyślnie = auto Przedstawia odsetek wartości odstających w zbiorze danych. Jeśli ustawimy go na domyślny, czyli auto, to określi próg jak w oryginale. Jeśli ustawione na pływające, zakres zanieczyszczenia będzie mieścił się w zakresie [0,0,5]. |
| 5 | random_state - int, instancja RandomState lub None, opcjonalne, default = none Ten parametr reprezentuje ziarno wygenerowanej liczby pseudolosowej, która jest używana podczas tasowania danych. Poniżej znajdują się opcje -
|
| 6 | max_features - int lub float, opcjonalne (domyślnie = 1.0) Reprezentuje liczbę cech, które należy narysować z X w celu przeszkolenia każdego estymatora podstawowego. Jeśli jako wartość wybierzemy int, narysuje on cechy max_features. Jeśli wybierzemy float jako jego wartość, narysuje on próbki max_features * X.shape []. |
| 7 | bootstrap - Boolean, opcjonalne (domyślnie = False) Jego domyślną opcją jest False, co oznacza, że próbkowanie byłoby wykonywane bez wymiany. Z drugiej strony, jeśli jest ustawiona na True, oznacza to, że poszczególne drzewa pasują do losowego podzbioru danych uczących, których próbka została zastąpiona. |
| 8 | n_jobs - int lub None, opcjonalne (domyślnie = None) Reprezentuje liczbę zadań, które mają być wykonywane równolegle fit() i predict() metody obie. |
| 9 | verbose - int, opcjonalne (domyślnie = 0) Ten parametr kontroluje szczegółowość procesu budowania drzewa. |
| 10 | warm_start - Bool, opcjonalne (domyślnie = False) Jeśli warm_start = true, możemy ponownie wykorzystać rozwiązanie poprzednich wywołań w celu dopasowania i dodać więcej estymatorów do zespołu. Ale jeśli jest ustawione na fałsz, musimy dopasować cały nowy las. |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez sklearn. ensemble.IsolationForest metoda -
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | estimators_ - lista DecisionTreeClassifier Zapewnienie zbioru wszystkich dopasowanych sub-estymatorów. |
| 2 | max_samples_ - liczba całkowita Podaje rzeczywistą liczbę użytych próbek. |
| 3 | offset_ - pływak Służy do definiowania funkcji decyzyjnej na podstawie wyników surowych. decision_function = score_samples -offset_ |
Implementation Example
Poniższy skrypt Pythona będzie używał sklearn. ensemble.IsolationForest metoda dopasowania 10 drzew do podanych danych
from sklearn.ensemble import IsolationForest
import numpy as np
X = np.array([[-1, -2], [-3, -3], [-3, -4], [0, 0], [-50, 60]])
OUTDClf = IsolationForest(n_estimators = 10)
OUTDclf.fit(X)Output
IsolationForest(
behaviour = 'old', bootstrap = False, contamination='legacy',
max_features = 1.0, max_samples = 'auto', n_estimators = 10, n_jobs=None,
random_state = None, verbose = 0
)Lokalny współczynnik odstający
Algorytm lokalnego współczynnika odstających (LOF) to kolejny skuteczny algorytm do wykrywania wartości odstających na danych o dużych wymiarach. Scikit-learn zapewnianeighbors.LocalOutlierFactormetoda, która oblicza wynik, zwany lokalnym współczynnikiem odstającym, odzwierciedlający stopień anomalności obserwacji. Główną logiką tego algorytmu jest wykrywanie próbek, które mają znacznie mniejszą gęstość niż sąsiedzi. Dlatego mierzy lokalne odchylenie gęstości danych punktów danych względem sąsiadów.
Parametry
Poniższa tabela zawiera parametry używane przez sklearn. neighbors.LocalOutlierFactor metoda
| Sr.No | Parametr i opis |
|---|---|
| 1 | n_neighbors - int, opcjonalne, domyślnie = 20 Reprezentuje liczbę sąsiadów używaną domyślnie dla zapytania kolanowego. Wszystkie próbki zostaną użyte, jeśli. |
| 2 | algorithm - opcjonalnie Który algorytm ma zostać użyty do obliczenia najbliższych sąsiadów.
|
| 3 | leaf_size - int, opcjonalne, domyślnie = 30 Wartość tego parametru może wpływać na szybkość konstrukcji i zapytania. Wpływa również na ilość pamięci wymaganej do przechowywania drzewa. Ten parametr jest przekazywany do algorytmów BallTree lub KdTree. |
| 4 | contamination - auto lub float, opcjonalnie, domyślnie = auto Przedstawia odsetek wartości odstających w zbiorze danych. Jeśli ustawimy go na domyślny, czyli auto, to określi próg jak w oryginale. Jeśli ustawione na pływające, zakres zanieczyszczenia będzie mieścił się w zakresie [0,0,5]. |
| 5 | metric - ciągowe lub wywoływalne, domyślnie Reprezentuje metrykę używaną do obliczania odległości. |
| 6 | P - int, opcjonalne (domyślnie = 2) Jest to parametr dla metryki Minkowskiego. P = 1 jest równoważne użyciu manhattan_distance, czyli L1, podczas gdy P = 2 jest równoważne użyciu euclidean_distance, czyli L2. |
| 7 | novelty - Boolean, (domyślnie = False) Domyślnie algorytm LOF jest używany do wykrywania wartości odstających, ale może być używany do wykrywania nowości, jeśli ustawimy nowość = true. |
| 8 | n_jobs - int lub None, opcjonalne (domyślnie = None) Reprezentuje liczbę zadań, które mają być uruchomione równolegle dla obu metod fit () i Predict (). |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez sklearn.neighbors.LocalOutlierFactor metoda -
| Sr.No | Atrybuty i opis |
|---|---|
| 1 | negative_outlier_factor_ - tablica numpy, kształt (n_samples,) Podanie przeciwnego LOF próbek szkoleniowych. |
| 2 | n_neighbors_ - liczba całkowita Podaje rzeczywistą liczbę sąsiadów używanych do zapytań sąsiadów. |
| 3 | offset_ - pływak Służy do definiowania etykiet binarnych z surowych wyników. |
Implementation Example
Poniższy skrypt Pythona będzie używał sklearn.neighbors.LocalOutlierFactor do skonstruowania klasy NeighborsClassifier z dowolnej tablicy odpowiadającej naszemu zestawowi danych
from sklearn.neighbors import NearestNeighbors
samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
LOFneigh = NearestNeighbors(n_neighbors = 1, algorithm = "ball_tree",p=1)
LOFneigh.fit(samples)Output
NearestNeighbors(
algorithm = 'ball_tree', leaf_size = 30, metric='minkowski',
metric_params = None, n_jobs = None, n_neighbors = 1, p = 1, radius = 1.0
)Example
Teraz możemy zapytać z tego skonstruowanego klasyfikatora, czy jest to punkt w szafie [0.5, 1., 1.5], używając następującego skryptu Pythona -
print(neigh.kneighbors([[.5, 1., 1.5]])Output
(array([[1.7]]), array([[1]], dtype = int64))Jednej klasy SVM
Jedną klasą SVM, wprowadzoną przez Schölkopfa i wsp., Jest nienadzorowane wykrywanie wartości odstających. Jest również bardzo wydajny w przypadku danych wielowymiarowych i szacuje wsparcie dla dystrybucji wielowymiarowej. Jest zaimplementowany wSupport Vector Machines moduł w Sklearn.svm.OneClassSVMobiekt. Do zdefiniowania granicy wymaga jądra (najczęściej używany jest RBF) i parametru skalarnego.
Aby lepiej zrozumieć, dopasujmy nasze dane do svm.OneClassSVM obiekt -
Przykład
from sklearn.svm import OneClassSVM
X = [[0], [0.89], [0.90], [0.91], [1]]
OSVMclf = OneClassSVM(gamma = 'scale').fit(X)Teraz możemy pobrać score_samples dla danych wejściowych w następujący sposób -
OSVMclf.score_samples(X)Wynik
array([1.12218594, 1.58645126, 1.58673086, 1.58645127, 1.55713767])Ten rozdział pomoże ci zrozumieć metody najbliższych sąsiadów w Sklearn.
Są dwa rodzaje metod uczenia się opartych na sąsiedztwie supervised i unsupervised. Uczenie się oparte na nadzorowanych sąsiadach może być wykorzystywane zarówno w przypadku problemów związanych z klasyfikacją, jak i predykcją regresji, ale jest używane głównie w przypadku problemów związanych z predykcją klasyfikacji w przemyśle.
Metody uczenia się oparte na sąsiadach nie mają wyspecjalizowanej fazy szkolenia i podczas klasyfikacji wykorzystuje wszystkie dane do szkolenia. Nie zakłada również niczego na temat danych bazowych. Z tego powodu są leniwi i nieparametryczni z natury.
Główną zasadą stojącą za metodami najbliższego sąsiada jest -
Aby znaleźć wstępnie zdefiniowaną liczbę próbek szkoleniowych w niewielkiej odległości od nowego punktu danych
Wytypuj etykietę na podstawie liczby próbek szkoleniowych.
W tym przypadku liczba próbek może być stałą zdefiniowaną przez użytkownika, jak w przypadku uczenia się sąsiada K-najbliższego sąsiada, lub może zmieniać się w zależności od lokalnej gęstości punktu, jak w przypadku uczenia się sąsiada na podstawie promienia.
moduł sklearn.neighbors
Scikit-Learn have sklearn.neighborsmoduł, który zapewnia funkcjonalność zarówno dla nienadzorowanych, jak i nadzorowanych metod uczenia się sąsiadów. Jako dane wejściowe klasy w tym module mogą obsługiwać tablice NumPy lubscipy.sparse matryce.
Rodzaje algorytmów
Poniżej przedstawiono różne typy algorytmów, które można zastosować w implementacji metod opartych na sąsiadach -
Brutalna siła
Brute-force obliczanie odległości między wszystkimi parami punktów w zbiorze danych zapewnia najbardziej naiwną implementację wyszukiwania sąsiadów. Matematycznie dla próbek N w wymiarach D skala podejścia brutalnej siły równa się0[DN2]
W przypadku małych próbek danych algorytm ten może być bardzo przydatny, ale staje się niewykonalny wraz ze wzrostem liczby próbek. Wyszukiwanie sąsiadów metodą Brute force można włączyć, wpisując słowo kluczowealgorithm=’brute’.
Drzewo KD
Jedną ze struktur danych opartych na drzewach, które zostały wynalezione w celu rozwiązania problemu nieefektywności obliczeniowej podejścia brute-force, jest struktura danych KD. Zasadniczo drzewo KD jest binarną strukturą drzewa, która jest nazywana drzewem K-wymiarowym. Rekurencyjnie dzieli przestrzeń parametrów wzdłuż osi danych, dzieląc ją na zagnieżdżone regiony ortograficzne, w których punkty danych są wypełnione.
Zalety
Oto kilka zalet algorytmu drzewa KD -
Construction is fast - Ponieważ partycjonowanie odbywa się tylko wzdłuż osi danych, konstrukcja drzewa KD jest bardzo szybka.
Less distance computations- Ten algorytm wymaga bardzo mniej obliczeń odległości, aby określić najbliższego sąsiada punktu zapytania. Trwa to tylko[ ()] obliczenia odległości.
Niedogodności
Fast for only low-dimensional neighbor searches- Jest bardzo szybki w przypadku niskowymiarowych (D <20) wyszukiwań sąsiadów, ale w miarę wzrostu D staje się nieefektywny. Ponieważ partycjonowanie odbywa się tylko wzdłuż osi danych,
Wyszukiwanie sąsiadów w drzewie KD można włączyć, wpisując słowo kluczowe algorithm=’kd_tree’.
Drzewo kulkowe
Ponieważ wiemy, że drzewo KD jest nieefektywne w wyższych wymiarach, dlatego w celu rozwiązania tej nieefektywności drzewa KD opracowano strukturę danych drzewa Ball. Matematycznie, rekurencyjnie dzieli dane na węzły określone przez centroidę C i promień r, w taki sposób, że każdy punkt w węźle leży w hiper-sferze określonej przez środek ciężkościC i promień r. Wykorzystuje nierówność trójkątów, podaną poniżej, co zmniejsza liczbę punktów kandydujących do wyszukiwania sąsiada
$$\arrowvert X+Y\arrowvert\leq \arrowvert X\arrowvert+\arrowvert Y\arrowvert$$Zalety
Oto kilka zalet algorytmu Ball Tree -
Efficient on highly structured data - Ponieważ drzewo kulowe dzieli dane na szereg zagnieżdżonych hipersfer, jest wydajne w przypadku wysoce ustrukturyzowanych danych.
Out-performs KD-tree - Drzewo kulowe przewyższa drzewo KD w dużych wymiarach, ponieważ ma sferyczną geometrię węzłów drzewa kul.
Niedogodności
Costly - Podział danych na szereg zagnieżdżonych hipersfer sprawia, że jego konstrukcja jest bardzo kosztowna.
Wyszukiwanie sąsiadów w drzewie piłek można włączyć, wpisując słowo kluczowe algorithm=’ball_tree’.
Wybieranie algorytmu dla najbliższych sąsiadów
Wybór optymalnego algorytmu dla danego zbioru danych zależy od następujących czynników -
Liczba próbek (N) i wymiarowość (D)
Są to najważniejsze czynniki, które należy wziąć pod uwagę przy wyborze algorytmu najbliższego sąsiada. To z powodów podanych poniżej -
Czas zapytania algorytmu Brute Force rośnie do O [DN].
Czas zapytania algorytmu drzewa Ball rośnie jako O [D log (N)].
Czas zapytania algorytmu drzewa KD zmienia się wraz z D w dziwny sposób, który jest bardzo trudny do scharakteryzowania. Gdy D <20, koszt wynosi O [D log (N)], a algorytm ten jest bardzo wydajny. Z drugiej strony jest nieefektywny w przypadku, gdy D> 20, ponieważ koszt wzrasta do prawie O [DN].
Struktura danych
Innym czynnikiem, który wpływa na wydajność tych algorytmów jest wewnętrzna wymiarowość danych lub rzadkość danych. Dzieje się tak, ponieważ może to mieć duży wpływ na czasy zapytań w algorytmach drzewa Ball i KD. Natomiast czas zapytania algorytmu Brute Force pozostaje niezmieniony przez strukturę danych. Generalnie algorytmy drzewa Ball i drzewa KD generują krótszy czas zapytań po wszczepieniu do rzadszych danych o mniejszej wewnętrznej wymiarowości.
Liczba sąsiadów (k)
Liczba sąsiadów (k) żądanych dla punktu zapytania wpływa na czas zapytania algorytmów drzewa Ball i drzewa KD. Ich czas zapytań staje się wolniejszy wraz ze wzrostem liczby sąsiadów (k). Podczas gdy czas zapytania Brute Force pozostanie niezmieniony przez wartość k.
Liczba punktów zapytania
Ponieważ wymagają one fazy konstrukcyjnej, zarówno algorytmy drzewa KD, jak i drzewa Ball będą skuteczne, jeśli istnieje duża liczba punktów zapytań. Z drugiej strony, jeśli istnieje mniejsza liczba punktów zapytania, algorytm Brute Force działa lepiej niż algorytmy drzewa KD i drzewa Ball.
k-NN (k-Nearest Neighbor), jeden z najprostszych algorytmów uczenia maszynowego, ma charakter nieparametryczny i leniwy. Nieparametryczny oznacza, że nie ma założenia co do podstawowego rozkładu danych, tj. Struktura modelu jest określana na podstawie zbioru danych. Uczenie się leniwe lub oparte na instancjach oznacza, że na potrzeby generowania modelu nie wymaga żadnych punktów danych szkoleniowych, a całe dane uczące są wykorzystywane w fazie testowania.
Algorytm k-NN składa się z następujących dwóch kroków -
Krok 1
Na tym etapie oblicza i przechowuje k najbliższych sąsiadów dla każdej próbki w zbiorze uczącym.
Krok 2
W tym kroku dla nieznakowanej próbki pobiera k najbliższych sąsiadów ze zbioru danych. Następnie spośród tych k-najbliższych sąsiadów przewiduje klasę poprzez głosowanie (wygrywa klasa z większością głosów).
Moduł, sklearn.neighbors który implementuje algorytm k-najbliższych sąsiadów, zapewnia funkcjonalność dla unsupervised jak również supervised metody uczenia się oparte na sąsiadach.
Najbliżsi sąsiedzi bez nadzoru implementują różne algorytmy (BallTree, KDTree lub Brute Force), aby znaleźć najbliższego sąsiada (ów) dla każdej próbki. Ta nienadzorowana wersja jest w zasadzie tylko krokiem 1, który omówiono powyżej, i podstawą wielu algorytmów (KNN i K-oznacza to słynny), które wymagają wyszukiwania sąsiada. Krótko mówiąc, jest to uczeń nienadzorowany za implementację wyszukiwania sąsiadów.
Z drugiej strony, uczenie się oparte na nadzorowanych sąsiadach jest wykorzystywane zarówno do klasyfikacji, jak i regresji.
Uczenie KNN bez nadzoru
Jak wspomniano, istnieje wiele algorytmów, takich jak KNN i K-średnie, które wymagają wyszukiwania najbliższego sąsiada. Dlatego Scikit-learn zdecydowała się zaimplementować część wyszukiwania sąsiadów jako własnego „ucznia”. Przyczyną wykonywania wyszukiwania sąsiadów jako oddzielnego ucznia jest to, że obliczanie całej odległości parami w celu znalezienia najbliższego sąsiada jest oczywiście mało wydajne. Przyjrzyjmy się modułowi używanemu przez Sklearn do implementacji uczenia się najbliższego sąsiada bez nadzoru wraz z przykładem.
Moduł nauki Scikit
sklearn.neighbors.NearestNeighborsjest modułem używanym do implementacji uczenia się najbliższego sąsiada bez nadzoru. Wykorzystuje określone algorytmy najbliższego sąsiada o nazwie BallTree, KDTree lub Brute Force. Innymi słowy, działa jako jednolity interfejs dla tych trzech algorytmów.
Parametry
Poniższa tabela zawiera parametry używane przez NearestNeighbors moduł -
| Sr.No | Parametr i opis |
|---|---|
| 1 | n_neighbors - int, opcjonalnie Liczba sąsiadów do zdobycia. Wartość domyślna to 5. |
| 2 | radius - pływak, opcjonalnie Ogranicza odległość sąsiadów do powrotu. Wartość domyślna to 1,0. |
| 3 | algorithm - {'auto', 'ball_tree', 'kd_tree', 'brute'}, opcjonalnie Ten parametr weźmie algorytm (BallTree, KDTree lub Brute-force), którego chcesz użyć do obliczenia najbliższych sąsiadów. Jeśli podasz „auto”, spróbuje wybrać najbardziej odpowiedni algorytm na podstawie wartości przekazanych do metody dopasowania. |
| 4 | leaf_size - int, opcjonalnie Może wpływać na szybkość konstrukcji i zapytań, a także ilość pamięci wymaganej do przechowywania drzewa. Jest przekazywany do BallTree lub KDTree. Chociaż optymalna wartość zależy od natury problemu, jej wartość domyślna to 30. |
| 5 | metric - ciągowe lub wywoływalne Jest to metryka używana do obliczania odległości między punktami. Możemy przekazać to jako ciąg lub funkcję wywoływalną. W przypadku funkcji wywoływalnej metryka jest wywoływana dla każdej pary wierszy, a wynikowa wartość jest rejestrowana. Jest mniej wydajne niż przekazywanie nazwy metryki jako ciągu. Do wyboru mamy metryki z scikit-learn lub scipy.spatial.distance. prawidłowe wartości są następujące - Scikit-learn - [„cosinus”, „manhattan”, „euklidesowy”, „l1”, „l2”, „blok miejski”] Scipy.spatial.distance - [„braycurtis”, „canberra”, „chebyshev”, „dice”, „hamming”, „jaccard”, „korelacja”, „kulsinski”, „mahalanobis”, „minkowski”, „rogerstanimoto”, „russellrao”, „ sokalmicheme ”,„ sokalsneath ”,„ seuclidean ”,„ sqeuclidean ”,„ yule ”]. Metryka domyślna to „Minkowski”. |
| 6 | P - liczba całkowita, opcjonalna Jest to parametr dla metryki Minkowskiego. Wartością domyślną jest 2, co jest równoważne użyciu Euclidean_distance (l2). |
| 7 | metric_params - dykt, opcjonalnie To są dodatkowe argumenty słów kluczowych dla funkcji metryki. Wartość domyślna to Brak. |
| 8 | N_jobs - int lub None, opcjonalnie Ponownie ustawia liczbę równoległych zadań do wykonania w celu wyszukiwania sąsiadów. Wartość domyślna to Brak. |
Implementation Example
Poniższy przykład znajdzie najbliższych sąsiadów między dwoma zestawami danych przy użyciu rozszerzenia sklearn.neighbors.NearestNeighbors moduł.
Najpierw musimy zaimportować wymagany moduł i pakiety -
from sklearn.neighbors import NearestNeighbors
import numpy as npTeraz po zaimportowaniu pakietów określamy zestawy danych pomiędzy którymi chcemy znaleźć najbliższych sąsiadów -
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])Następnie zastosuj nienadzorowany algorytm uczenia się w następujący sposób -
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm = 'ball_tree')Następnie dopasuj model do zestawu danych wejściowych.
nrst_neigh.fit(Input_data)Teraz znajdź K-sąsiadów zbioru danych. Zwróci wskaźniki i odległości sąsiadów każdego punktu.
distances, indices = nbrs.kneighbors(Input_data)
indicesOutput
array(
[
[0, 1, 3],
[1, 2, 0],
[2, 1, 0],
[3, 4, 0],
[4, 5, 3],
[5, 6, 4],
[6, 5, 4]
], dtype = int64
)
distancesOutput
array(
[
[0. , 1.41421356, 2.23606798],
[0. , 1.41421356, 1.41421356],
[0. , 1.41421356, 2.82842712],
[0. , 1.41421356, 2.23606798],
[0. , 1.41421356, 1.41421356],
[0. , 1.41421356, 1.41421356],
[0. , 1.41421356, 2.82842712]
]
)Powyższe dane wyjściowe pokazują, że najbliższym sąsiadem każdego punktu jest sam punkt, tj. W punkcie zero. Dzieje się tak, ponieważ zestaw zapytań pasuje do zestawu uczącego.
Example
Możemy również pokazać połączenie między sąsiednimi punktami, tworząc rzadki wykres w następujący sposób -
nrst_neigh.kneighbors_graph(Input_data).toarray()Output
array(
[
[1., 1., 0., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0., 0.],
[1., 1., 1., 0., 0., 0., 0.],
[1., 0., 0., 1., 1., 0., 0.],
[0., 0., 0., 1., 1., 1., 0.],
[0., 0., 0., 0., 1., 1., 1.],
[0., 0., 0., 0., 1., 1., 1.]
]
)Kiedyś dopasujemy bez nadzoru NearestNeighbors modelu dane będą przechowywane w strukturze danych opartej na wartości ustawionej dla argumentu ‘algorithm’. Potem możemy używać tego uczącego się bez nadzorukneighbors w modelu, który wymaga wyszukiwania sąsiadów.
Complete working/executable program
from sklearn.neighbors import NearestNeighbors
import numpy as np
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm='ball_tree')
nrst_neigh.fit(Input_data)
distances, indices = nbrs.kneighbors(Input_data)
indices
distances
nrst_neigh.kneighbors_graph(Input_data).toarray()Nadzorowane uczenie się KNN
Uczenie się oparte na nadzorowanych sąsiadach służy do:
- Klasyfikacja dla danych z dyskretnymi etykietami
- Regresja dla danych z ciągłymi etykietami.
Najbliższy klasyfikator sąsiada
Klasyfikację opartą na sąsiadach możemy zrozumieć za pomocą następujących dwóch cech -
- Oblicza się go na podstawie zwykłej większości głosów najbliższych sąsiadów każdego punktu.
- Po prostu przechowuje instancje danych szkoleniowych, dlatego jest to rodzaj uczenia się nieuogólniającego.
Moduły do nauki Scikit
Poniżej przedstawiono dwa różne typy klasyfikatorów najbliższych sąsiadów używane przez scikit-learn -
| S.No. | Klasyfikatory i opis |
|---|---|
| 1. | KNeighborsClassifier K w nazwie tego klasyfikatora reprezentuje k najbliższych sąsiadów, gdzie k jest liczbą całkowitą określoną przez użytkownika. Stąd, jak sama nazwa wskazuje, ten klasyfikator implementuje uczenie się w oparciu o k najbliższych sąsiadów. Wybór wartości k zależy od danych. |
| 2. | RadiusNeighborsClassifier Promień w nazwie tego klasyfikatora reprezentuje najbliższych sąsiadów w określonym promieniu r, gdzie r jest wartością zmiennoprzecinkową określoną przez użytkownika. Stąd, jak sama nazwa wskazuje, ten klasyfikator implementuje uczenie się na podstawie liczby sąsiadów w ustalonym promieniu r każdego punktu szkoleniowego. |
Regresor najbliższego sąsiada
Jest stosowany w przypadkach, gdy etykiety danych mają charakter ciągły. Przypisane etykiety danych są obliczane na podstawie średniej z etykiet najbliższych sąsiadów.
Poniżej przedstawiono dwa różne typy regresorów najbliższego sąsiada używane przez scikit-learn -
KNeighborsRegressor
K w nazwie tego regresora reprezentuje k najbliższych sąsiadów, gdzie k jest integer valueokreślone przez użytkownika. Stąd, jak sama nazwa wskazuje, regresor ten implementuje uczenie się w oparciu o k najbliższych sąsiadów. Wybór wartości k zależy od danych. Zrozummy to bardziej na przykładzie implementacji.
Poniżej przedstawiono dwa różne typy regresorów najbliższego sąsiada używane przez scikit-learn -
Przykład implementacji
W tym przykładzie zaimplementujemy KNN na zestawie danych o nazwie Iris Flower zbiór danych za pomocą scikit-learn KNeighborsRegressor.
Najpierw zaimportuj zestaw danych tęczówki w następujący sposób -
from sklearn.datasets import load_iris
iris = load_iris()Teraz musimy podzielić dane na dane treningowe i testowe. Będziemy używać Sklearntrain_test_split funkcja dzielenia danych na stosunek 70 (dane treningowe) i 20 (dane testowe) -
X = iris.data[:, :4]
y = iris.target
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)Następnie będziemy wykonywać skalowanie danych za pomocą modułu wstępnego przetwarzania Sklearn w następujący sposób -
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)Następnie zaimportuj plik KNeighborsRegressor ze Sklearn i podaj wartość sąsiadów w następujący sposób.
Przykład
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 8)
knnr.fit(X_train, y_train)Wynik
KNeighborsRegressor(
algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
metric_params = None, n_jobs = None, n_neighbors = 8, p = 2,
weights = 'uniform'
)Przykład
Teraz możemy znaleźć MSE (błąd średniokwadratowy) w następujący sposób -
print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))Wynik
The MSE is: 4.4333349609375Przykład
Teraz użyj go do przewidzenia wartości w następujący sposób -
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))Wynik
[0.66666667]Kompletny działający / wykonywalny program
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
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)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=8)
knnr.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))RadiusNeighborsRegressor
Promień w nazwie tego regresora reprezentuje najbliższych sąsiadów w określonym promieniu r, gdzie r jest wartością zmiennoprzecinkową określoną przez użytkownika. Stąd, jak sugeruje nazwa, regresor ten implementuje uczenie się na podstawie liczby sąsiadów w ustalonym promieniu r każdego punktu szkoleniowego. Zrozummy to bardziej z pomocą, jeśli przykład implementacji -
Przykład implementacji
W tym przykładzie zaimplementujemy KNN na zestawie danych o nazwie Iris Flower zbiór danych za pomocą scikit-learn RadiusNeighborsRegressor -
Najpierw zaimportuj zestaw danych tęczówki w następujący sposób -
from sklearn.datasets import load_iris
iris = load_iris()Teraz musimy podzielić dane na dane treningowe i testowe. Będziemy używać funkcji Sklearn train_test_split, aby podzielić dane na stosunek 70 (dane treningowe) i 20 (dane testowe) -
X = iris.data[:, :4]
y = iris.target
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)Następnie będziemy wykonywać skalowanie danych za pomocą modułu wstępnego przetwarzania Sklearn w następujący sposób -
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)Następnie zaimportuj plik RadiusneighborsRegressor ze Sklearn i podaj wartość promienia w następujący sposób -
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X_train, y_train)Przykład
Teraz możemy znaleźć MSE (błąd średniokwadratowy) w następujący sposób -
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))Wynik
The MSE is: The MSE is: 5.666666666666667Przykład
Teraz użyj go do przewidzenia wartości w następujący sposób -
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))Wynik
[1.]Kompletny działający / wykonywalny program
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
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)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))Naiwne metody Bayesa to zestaw algorytmów uczenia nadzorowanego opartych na zastosowaniu twierdzenia Bayesa z silnym założeniem, że wszystkie predyktory są od siebie niezależne, tj. Obecność cechy w klasie jest niezależna od obecności jakiejkolwiek innej cechy w tym samym klasa. To naiwne założenie, dlatego metody te nazywane są metodami Naiwego Bayesa.
Twierdzenie Bayesa stwierdza następującą zależność w celu znalezienia późniejszego prawdopodobieństwa klasy, tj. Prawdopodobieństwa etykiety i niektórych obserwowanych cech, $P\left(\begin{array}{c} Y\arrowvert features\end{array}\right)$.
$$P\left(\begin{array}{c} Y\arrowvert features\end{array}\right)=\left(\frac{P\lgroup Y\rgroup P\left(\begin{array}{c} features\arrowvert Y\end{array}\right)}{P\left(\begin{array}{c} features\end{array}\right)}\right)$$Tutaj, $P\left(\begin{array}{c} Y\arrowvert features\end{array}\right)$ jest późniejszym prawdopodobieństwem klasy.
$P\left(\begin{array}{c} Y\end{array}\right)$ jest wcześniejszym prawdopodobieństwem klasy.
$P\left(\begin{array}{c} features\arrowvert Y\end{array}\right)$ jest prawdopodobieństwem, które jest prawdopodobieństwem predyktora danej klasy.
$P\left(\begin{array}{c} features\end{array}\right)$ jest wcześniejszym prawdopodobieństwem predyktora.
Scikit-learn zapewnia różne naiwne modele klasyfikatorów Bayesa, mianowicie Gaussa, Wielomian, Dopełnienie i Bernoulliego. Wszystkie różnią się głównie założeniem, które przyjmują co do dystrybucji$P\left(\begin{array}{c} features\arrowvert Y\end{array}\right)$ czyli prawdopodobieństwo predyktora danej klasy.
| Sr.No | Opis modelu |
|---|---|
| 1 | Gaussian Naïve Bayes Naiwny klasyfikator Gaussa Bayesa zakłada, że dane z każdej etykiety pochodzą z prostego rozkładu Gaussa. |
| 2 | Wielomianowy Naïve Bayes Zakłada, że cechy pochodzą z prostego rozkładu wielomianowego. |
| 3 | Bernoulli Naïve Bayes Założenie w tym modelu jest takie, że cechy mają charakter binarny (0 i 1). Zastosowaniem klasyfikacji Bernoulliego Naïve Bayesa jest klasyfikacja tekstu z modelem „worka słów” |
| 4 | Uzupełnienie Naïve Bayes Został zaprojektowany, aby skorygować surowe założenia przyjęte przez wielomianowy klasyfikator Bayesa. Ten rodzaj klasyfikatora NB jest odpowiedni dla niezrównoważonych zestawów danych |
Budowanie naiwnego klasyfikatora Bayesa
Możemy również zastosować klasyfikator Naïve Bayes w zbiorze danych Scikit-learn. W poniższym przykładzie stosujemy GaussianNB i dopasowujemy zestaw danych raka piersi Scikit-leran.
Przykład
Import Sklearn
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
data = load_breast_cancer()
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
print(label_names)
print(labels[0])
print(feature_names[0])
print(features[0])
train, test, train_labels, test_labels = train_test_split(
features,labels,test_size = 0.40, random_state = 42
)
from sklearn.naive_bayes import GaussianNB
GNBclf = GaussianNB()
model = GNBclf.fit(train, train_labels)
preds = GNBclf.predict(test)
print(preds)Wynik
[
1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1
1 1 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1
1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0
1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0
1 1 0 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1
0 1 1 0 0 1 0 1 1 0 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1
1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0
1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1
1 1 1 1 0 1 0 0 1 1 0 1
]Powyższy wynik składa się z serii zer i jedynek, które są w zasadzie wartościami przewidywanymi z klas nowotworów, mianowicie złośliwych i łagodnych.
W tym rozdziale poznamy metodę uczenia się w Sklearn, która jest nazywana drzewami decyzyjnymi.
Decisions tress (DT) to najpotężniejsza nieparametryczna metoda nadzorowanego uczenia się. Mogą być używane do zadań klasyfikacyjnych i regresyjnych. Głównym celem DT jest stworzenie modelu przewidującego docelową wartość zmiennej poprzez poznanie prostych reguł decyzyjnych wydedukowanych z cech danych. Drzewa decyzyjne mają dwie główne jednostki; jeden to węzeł główny, w którym dane są podzielone, a drugi to węzły decyzyjne lub liście, w których otrzymaliśmy ostateczne dane wyjściowe.
Algorytmy drzewa decyzyjnego
Poniżej opisano różne algorytmy drzew decyzyjnych -
ID3
Został opracowany przez Rossa Quinlana w 1986 roku. Nazywa się go również Iteratywnym Dichotomizerem 3. Głównym celem tego algorytmu jest znalezienie tych cech kategorialnych dla każdego węzła, które przyniosą największe zyski informacyjne dla celów kategorialnych.
Pozwala rozwinąć drzewo do maksymalnego rozmiaru, a następnie, aby poprawić zdolność drzewa do niewidocznych danych, stosuje krok przycinania. Wynikiem tego algorytmu byłoby drzewo wielościeżkowe.
C4.5
Jest następcą ID3 i dynamicznie definiuje dyskretny atrybut, który dzieli ciągłą wartość atrybutu na dyskretny zestaw interwałów. To jest powód, dla którego usunął ograniczenie funkcji kategorycznych. Konwertuje wyuczone drzewo ID3 na zestawy reguł „IF-THEN”.
Aby określić kolejność, w jakiej te reguły powinny być stosowane, najpierw zostanie oceniona dokładność każdej reguły.
C5.0
Działa podobnie jak C4.5, ale zużywa mniej pamięci i tworzy mniejsze zestawy reguł. Jest dokładniejszy niż C4.5.
WÓZEK
Nazywa się to algorytmem drzew klasyfikacyjnych i regresyjnych. Zasadniczo generuje binarne podziały za pomocą funkcji i progu, które dają największy przyrost informacji w każdym węźle (zwanym indeksem Giniego).
Jednorodność zależy od indeksu Giniego, im wyższa wartość indeksu Giniego, tym większa byłaby jednorodność. Jest podobny do algorytmu C4.5, z tą różnicą, że nie oblicza zestawów reguł i nie obsługuje również numerycznych zmiennych docelowych (regresja).
Klasyfikacja za pomocą drzew decyzyjnych
W tym przypadku zmienne decyzyjne są jakościowe.
Sklearn Module - Biblioteka Scikit-learn zawiera nazwę modułu DecisionTreeClassifier do wykonywania klasyfikacji wieloklasowej na zbiorze danych.
Parametry
Poniższa tabela zawiera parametry używane przez sklearn.tree.DecisionTreeClassifier moduł -
| Sr.No | Parametr i opis |
|---|---|
| 1 | criterion - string, opcjonalnie domyślnie = „gini” Reprezentuje funkcję mierzenia jakości podziału. Obsługiwane kryteria to „gini” i „entropia”. Wartością domyślną jest gini, które oznacza nieczystość Giniego, podczas gdy entropia służy do uzyskiwania informacji. |
| 2 | splitter - string, opcjonalne domyślne = „best” Informuje model, którą strategię od „najlepszej” lub „losowej”, aby wybrać podział w każdym węźle. |
| 3 | max_depth - int lub None, opcjonalnie domyślnie = None Ten parametr decyduje o maksymalnej głębokości drzewa. Wartością domyślną jest None, co oznacza, że węzły będą się rozszerzać, dopóki wszystkie liście nie będą czyste lub dopóki wszystkie liście nie będą zawierać mniej niż min_smaples_split próbek. |
| 4 | min_samples_split - int, float, opcjonalnie default = 2 Ten parametr zapewnia minimalną liczbę próbek wymaganych do podzielenia węzła wewnętrznego. |
| 5 | min_samples_leaf - int, float, opcjonalnie domyślnie = 1 Ten parametr zapewnia minimalną liczbę próbek, które muszą znajdować się w węźle liścia. |
| 6 | min_weight_fraction_leaf - float, opcjonalnie domyślnie = 0. Dzięki temu parametrowi model otrzyma minimalny ważony ułamek sumy wag wymaganych, aby znajdować się w węźle liścia. |
| 7 | max_features - int, float, string lub None, opcjonalnie default = None Daje modelowi liczbę funkcji, które należy wziąć pod uwagę przy poszukiwaniu najlepszego podziału. |
| 8 | random_state - int, instancja RandomState lub None, opcjonalne, default = none Ten parametr reprezentuje ziarno wygenerowanej liczby pseudolosowej, która jest używana podczas tasowania danych. Poniżej znajdują się opcje -
|
| 9 | max_leaf_nodes - int lub None, opcjonalnie domyślnie = None Ten parametr pozwoli wyhodować drzewo z max_leaf_nodes w najlepszy sposób. Wartością domyślną jest brak, co oznacza, że byłaby nieograniczona liczba węzłów liści. |
| 10 | min_impurity_decrease - float, opcjonalnie domyślnie = 0. Ta wartość działa jako kryterium podziału węzła, ponieważ model podzieli węzeł, jeśli ten podział spowoduje zmniejszenie zanieczyszczenia większe lub równe min_impurity_decrease value. |
| 11 | min_impurity_split - float, domyślnie = 1e-7 Stanowi próg wczesnego zatrzymania wzrostu drzew. |
| 12 | class_weight - dict, lista dykt, „zrównoważony” lub brak, domyślnie = brak Reprezentuje wagi związane z klasami. Formularz to {class_label: weight}. Jeśli użyjemy opcji domyślnej, oznacza to, że wszystkie klasy mają mieć wagę jeden. Z drugiej strony, jeśli wybierzeszclass_weight: balanced, użyje wartości y do automatycznego dostosowania wag. |
| 13 | presort - bool, opcjonalnie domyślnie = False Informuje model, czy należy wstępnie posortować dane, aby przyspieszyć znajdowanie najlepszych podziałów dopasowania. Wartość domyślna to false, ale ustawienie true może spowolnić proces uczenia. |
Atrybuty
Poniższa tabela zawiera atrybuty używane przez sklearn.tree.DecisionTreeClassifier moduł -
| Sr.No | Parametr i opis |
|---|---|
| 1 | feature_importances_ - tablica kształtów = [n_features] Ten atrybut zwróci ważność funkcji. |
| 2 | classes_: - tablica shape = [n_classes] lub lista takich tablic Reprezentuje etykiety klas, tj. Problem z pojedynczym wyjściem lub listę tablic etykiet klas, tj. Problem z wieloma wyjściami. |
| 3 | max_features_ - wew Reprezentuje wydedukowaną wartość parametru max_features. |
| 4 | n_classes_ - int lub list Reprezentuje liczbę klas, tj. Problem z jednym wyjściem lub listę klas dla każdego wyjścia, tj. Problem z wieloma wyjściami. |
| 5 | n_features_ - wew Podaje liczbę features kiedy wykonywana jest metoda fit (). |
| 6 | n_outputs_ - wew Podaje liczbę outputs kiedy wykonywana jest metoda fit (). |
Metody
Poniższa tabela zawiera metody używane przez sklearn.tree.DecisionTreeClassifier moduł -
| Sr.No | Parametr i opis |
|---|---|
| 1 | apply(self, X [, check_input]) Ta metoda zwróci indeks liścia. |
| 2 | decision_path(self, X [, check_input]) Jak sama nazwa wskazuje, ta metoda zwróci ścieżkę decyzji w drzewie |
| 3 | fit(self, X, y [, sample_weight,…]) fit () zbuduje klasyfikator drzewa decyzyjnego z podanego zbioru uczącego (X, y). |
| 4 | get_depth(samego siebie) Jak sama nazwa wskazuje, ta metoda zwróci głębokość drzewa decyzyjnego |
| 5 | get_n_leaves(samego siebie) Jak sama nazwa wskazuje, ta metoda zwróci liczbę liści drzewa decyzyjnego. |
| 6 | get_params(ja [, głęboko]) Możemy użyć tej metody, aby uzyskać parametry do estymatora. |
| 7 | predict(self, X [, check_input]) Przewiduje wartość klasy dla X. |
| 8 | predict_log_proba(ja, X) Przewiduje logarytm prawdopodobieństwa klas dostarczonych przez nas próbek wejściowych, X. |
| 9 | predict_proba(self, X [, check_input]) Przewiduje prawdopodobieństwa klas dostarczonych przez nas próbek wejściowych, X. |
| 10 | score(self, X, y [, sample_weight]) Jak sama nazwa wskazuje, metoda score () zwróci średnią dokładność danych testowych i etykiet. |
| 11 | set_params(własne, \ * \ * parametry) Tą metodą możemy ustawić parametry estymatora. |
Przykład implementacji
Poniższy skrypt Pythona będzie używał sklearn.tree.DecisionTreeClassifier moduł do skonstruowania klasyfikatora do przewidywania płci męskiej lub żeńskiej na podstawie naszego zbioru danych zawierającego 25 próbek i dwie cechy, a mianowicie „wysokość” i „długość włosów” -
from sklearn import tree
from sklearn.model_selection import train_test_split
X=[[165,19],[175,32],[136,35],[174,65],[141,28],[176,15]
,[131,32],[166,6],[128,32],[179,10],[136,34],[186,2],[12
6,25],[176,28],[112,38],[169,9],[171,36],[116,25],[196,2
5], [196,38], [126,40], [197,20], [150,25], [140,32],[136,35]]
Y=['Man','Woman','Woman','Man','Woman','Man','Woman','Ma
n','Woman','Man','Woman','Man','Woman','Woman','Woman','
Man','Woman','Woman','Man', 'Woman', 'Woman', 'Man', 'Man', 'Woman', 'Woman']
data_feature_names = ['height','length of hair']
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.3, random_state = 1)
DTclf = tree.DecisionTreeClassifier()
DTclf = clf.fit(X,Y)
prediction = DTclf.predict([[135,29]])
print(prediction)Wynik
['Woman']Możemy również przewidzieć prawdopodobieństwo każdej klasy za pomocą następującej metody Python Predict_proba () w następujący sposób -
Przykład
prediction = DTclf.predict_proba([[135,29]])
print(prediction)Wynik
[[0. 1.]]Regresja z drzewami decyzyjnymi
W tym przypadku zmienne decyzyjne są ciągłe.
Sklearn Module - Biblioteka Scikit-learn zawiera nazwę modułu DecisionTreeRegressor do stosowania drzew decyzyjnych w problemach regresji.
Parametry
Parametry używane przez DecisionTreeRegressor są prawie takie same, jak te, które zostały użyte w programie DecisionTreeClassifiermoduł. Różnica polega na parametrze „kryterium”. DlaDecisionTreeRegressor moduły ‘criterion: string, opcjonalny parametr default = „mse” 'ma następujące wartości -
mse- Oznacza średni kwadrat błędu. Odpowiada redukcji wariancji jako kryterium wyboru cechy. Minimalizuje utratę L2 przy użyciu średniej z każdego węzła końcowego.
freidman_mse - Używa również błędu średniokwadratowego, ale z wynikiem poprawy Friedmana.
mae- Oznacza średni błąd bezwzględny. Minimalizuje utratę L1 przy użyciu mediany każdego węzła końcowego.
Inną różnicą jest to, że nie ma ‘class_weight’ parametr.
Atrybuty
Atrybuty DecisionTreeRegressor są również takie same jak te z DecisionTreeClassifiermoduł. Różnica polega na tym, że nie ma‘classes_’ i ‘n_classes_atrybuty.
Metody
Metody DecisionTreeRegressor są również takie same jak te z DecisionTreeClassifiermoduł. Różnica polega na tym, że nie ma‘predict_log_proba()’ i ‘predict_proba()’atrybuty.
Przykład implementacji
Metoda fit () w modelu regresji drzewa decyzyjnego przyjmuje zmiennoprzecinkowe wartości y. zobaczmy prosty przykład implementacji przy użyciuSklearn.tree.DecisionTreeRegressor -
from sklearn import tree
X = [[1, 1], [5, 5]]
y = [0.1, 1.5]
DTreg = tree.DecisionTreeRegressor()
DTreg = clf.fit(X, y)Po dopasowaniu możemy użyć tego modelu regresji do prognozowania w następujący sposób -
DTreg.predict([[4, 5]])Wynik
array([1.5])Ten rozdział pomoże ci zrozumieć losowe drzewa decyzyjne w Sklearn.
Randomizowane algorytmy drzew decyzyjnych
Ponieważ wiemy, że DT jest zwykle trenowany przez rekurencyjne dzielenie danych, ale jest podatny na nadmierne dopasowanie, został przekształcony w losowe lasy przez trenowanie wielu drzew w różnych podpróbkach danych. Pliksklearn.ensemble moduł posiada dwa algorytmy oparte na losowych drzewach decyzyjnych -
Algorytm Random Forest
Dla każdego rozważanego elementu oblicza optymalną lokalnie kombinację cecha / podział. W Random forest każde drzewo decyzyjne w zespole jest budowane z próbki pobranej z zastępstwem ze zbioru uczącego, a następnie otrzymuje prognozę z każdego z nich i ostatecznie wybiera najlepsze rozwiązanie w drodze głosowania. Może być używany zarówno do zadań klasyfikacyjnych, jak i regresyjnych.
Klasyfikacja z losowym lasem
Aby utworzyć losowy klasyfikator lasu, moduł Scikit-learning zapewnia sklearn.ensemble.RandomForestClassifier. Podczas tworzenia losowego klasyfikatora lasu głównymi parametrami używanymi przez ten moduł są‘max_features’ i ‘n_estimators’.
Tutaj, ‘max_features’to rozmiar losowych podzbiorów cech, które należy wziąć pod uwagę podczas podziału węzła. Jeśli ustawimy wartość tego parametru na none, wówczas uwzględni wszystkie cechy, a nie losowy podzbiór. Z drugiej strony,n_estimatorsto liczba drzew w lesie. Im większa liczba drzew, tym lepszy wynik. Ale również obliczenie zajmie więcej czasu.
Przykład realizacji
W poniższym przykładzie tworzymy losowy klasyfikator lasu przy użyciu sklearn.ensemble.RandomForestClassifier a także sprawdzanie jego dokładności również za pomocą cross_val_score moduł.
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_blobs
from sklearn.ensemble import RandomForestClassifier
X, y = make_blobs(n_samples = 10000, n_features = 10, centers = 100,random_state = 0) RFclf = RandomForestClassifier(n_estimators = 10,max_depth = None,min_samples_split = 2, random_state = 0)
scores = cross_val_score(RFclf, X, y, cv = 5)
scores.mean()Wynik
0.9997Przykład
Możemy również użyć zestawu danych sklearn do zbudowania klasyfikatora Random Forest. Jak w poniższym przykładzie używamy zestawu danych tęczówki. Znajdziemy również jego wynik dokładności i macierz pomyłki.
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
path = "https://archive.ics.uci.edu/ml/machine-learning-database
s/iris/iris.data"
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
dataset = pd.read_csv(path, names = headernames)
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)
RFclf = RandomForestClassifier(n_estimators = 50)
RFclf.fit(X_train, y_train)
y_pred = RFclf.predict(X_test)
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)Wynik
Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 14
Iris-versicolor 1.00 0.95 0.97 19
Iris-virginica 0.92 1.00 0.96 12
micro avg 0.98 0.98 0.98 45
macro avg 0.97 0.98 0.98 45
weighted avg 0.98 0.98 0.98 45
Accuracy: 0.9777777777777777Regresja z losowym lasem
Moduł Scikit-learning umożliwia tworzenie losowej regresji lasu sklearn.ensemble.RandomForestRegressor. Podczas budowania losowego regresora leśnego użyje tych samych parametrów, które są używane przezsklearn.ensemble.RandomForestClassifier.
Przykład realizacji
W poniższym przykładzie tworzymy losowy regresor lasu przy użyciu sklearn.ensemble.RandomForestregressor a także przewidywanie nowych wartości za pomocą metody Predict ().
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 10, n_informative = 2,random_state = 0, shuffle = False)
RFregr = RandomForestRegressor(max_depth = 10,random_state = 0,n_estimators = 100)
RFregr.fit(X, y)Wynik
RandomForestRegressor(
bootstrap = True, criterion = 'mse', max_depth = 10,
max_features = 'auto', max_leaf_nodes = None,
min_impurity_decrease = 0.0, min_impurity_split = None,
min_samples_leaf = 1, min_samples_split = 2,
min_weight_fraction_leaf = 0.0, n_estimators = 100, n_jobs = None,
oob_score = False, random_state = 0, verbose = 0, warm_start = False
)Po dopasowaniu możemy przewidzieć na podstawie modelu regresji w następujący sposób -
print(RFregr.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))Wynik
[98.47729198]Metody dodatkowego drzewa
Dla każdej rozpatrywanej funkcji wybiera losową wartość podziału. Zaletą stosowania dodatkowych metod drzewa jest to, że pozwala to nieco bardziej zmniejszyć wariancję modelu. Wadą stosowania tych metod jest to, że nieznacznie zwiększa to odchylenie.
Klasyfikacja metodą dodatkowego drzewa
Do tworzenia klasyfikatora przy użyciu metody Extra-tree zapewnia moduł Scikit-learn sklearn.ensemble.ExtraTreesClassifier. Używa tych samych parametrów, które są używane przezsklearn.ensemble.RandomForestClassifier. Jedyna różnica polega na tym, że omawiany powyżej sposób buduje drzewa.
Przykład realizacji
W poniższym przykładzie tworzymy losowy klasyfikator lasu przy użyciu sklearn.ensemble.ExtraTreeClassifier a także sprawdzanie jego dokładności za pomocą cross_val_score moduł.
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_blobs
from sklearn.ensemble import ExtraTreesClassifier
X, y = make_blobs(n_samples = 10000, n_features = 10, centers=100,random_state = 0)
ETclf = ExtraTreesClassifier(n_estimators = 10,max_depth = None,min_samples_split = 10, random_state = 0)
scores = cross_val_score(ETclf, X, y, cv = 5)
scores.mean()Wynik
1.0Przykład
Możemy również użyć zestawu danych sklearn do zbudowania klasyfikatora przy użyciu metody Extra-Tree. Jak w poniższym przykładzie używamy zestawu danych Pima-Indian.
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
num_trees = 150
max_features = 5
ETclf = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)
results = cross_val_score(ETclf, X, Y, cv=kfold)
print(results.mean())Wynik
0.7551435406698566Regresja za pomocą metody dodatkowego drzewa
Do tworzenia Extra-Tree regresji, zapewnia moduł Scikit-learning sklearn.ensemble.ExtraTreesRegressor. Podczas budowania losowego regresora leśnego użyje tych samych parametrów, które są używane przezsklearn.ensemble.ExtraTreesClassifier.
Przykład realizacji
W poniższym przykładzie stosujemy sklearn.ensemble.ExtraTreesregressori na tych samych danych, które wykorzystaliśmy podczas tworzenia losowego regresora lasu. Zobaczmy różnicę w danych wyjściowych
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 10, n_informative = 2,random_state = 0, shuffle = False)
ETregr = ExtraTreesRegressor(max_depth = 10,random_state = 0,n_estimators = 100)
ETregr.fit(X, y)Wynik
ExtraTreesRegressor(bootstrap = False, criterion = 'mse', max_depth = 10,
max_features = 'auto', max_leaf_nodes = None,
min_impurity_decrease = 0.0, min_impurity_split = None,
min_samples_leaf = 1, min_samples_split = 2,
min_weight_fraction_leaf = 0.0, n_estimators = 100, n_jobs = None,
oob_score = False, random_state = 0, verbose = 0, warm_start = False)Przykład
Po dopasowaniu możemy przewidzieć na podstawie modelu regresji w następujący sposób -
print(ETregr.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))Wynik
[85.50955817]W tym rozdziale poznamy metody wspomagania w Sklearn, które umożliwiają zbudowanie modelu zespołowego.
Metody wspomagające budują model zespołowy w sposób przyrostowy. Główną zasadą jest przyrostowe budowanie modelu poprzez sekwencyjne szkolenie każdego podstawowego estymatora modelu. Aby zbudować potężny zespół, metody te w zasadzie łączą kilkutygodniowych uczniów, którzy są sekwencyjnie trenowani na wielu iteracjach danych szkoleniowych. Moduł sklearn.ensemble ma następujące dwie metody zwiększania.
AdaBoost
Jest to jedna z najbardziej skutecznych metod wzmacniających, której głównym kluczem jest sposób, w jaki nadają wagi instancjom w zbiorze danych. Dlatego algorytm musi poświęcać mniej uwagi instancjom podczas konstruowania kolejnych modeli.
Klasyfikacja z AdaBoost
Do tworzenia klasyfikatora AdaBoost służy moduł Scikit-learn sklearn.ensemble.AdaBoostClassifier. Podczas budowania tego klasyfikatora głównym parametrem używanym przez ten moduł jestbase_estimator. Tutaj base_estimator jest wartościąbase estimatorz którego zbudowany jest wzmocniony zespół. Jeśli wybierzemy wartość tego parametru na none, to estymator bazowy będzieDecisionTreeClassifier(max_depth=1).
Przykład realizacji
W poniższym przykładzie tworzymy klasyfikator AdaBoost przy użyciu sklearn.ensemble.AdaBoostClassifier a także przewidywanie i sprawdzanie wyniku.
from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples = 1000, n_features = 10,n_informative = 2, n_redundant = 0,random_state = 0, shuffle = False)
ADBclf = AdaBoostClassifier(n_estimators = 100, random_state = 0)
ADBclf.fit(X, y)Wynik
AdaBoostClassifier(algorithm = 'SAMME.R', base_estimator = None,
learning_rate = 1.0, n_estimators = 100, random_state = 0)Przykład
Po dopasowaniu możemy przewidzieć nowe wartości w następujący sposób -
print(ADBclf.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))Wynik
[1]Przykład
Teraz możemy sprawdzić wynik w następujący sposób -
ADBclf.score(X, y)Wynik
0.995Przykład
Możemy również użyć zestawu danych sklearn do zbudowania klasyfikatora przy użyciu metody Extra-Tree. Na przykład w przykładzie podanym poniżej używamy zbioru danych Pima-Indian.
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names = headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
seed = 5
kfold = KFold(n_splits = 10, random_state = seed)
num_trees = 100
max_features = 5
ADBclf = AdaBoostClassifier(n_estimators = num_trees, max_features = max_features)
results = cross_val_score(ADBclf, X, Y, cv = kfold)
print(results.mean())Wynik
0.7851435406698566Regresja z AdaBoost
Do tworzenia regresora metodą Ada Boost służy biblioteka Scikit-learn sklearn.ensemble.AdaBoostRegressor. Podczas budowania regresora użyje tych samych parametrów, które są używane przezsklearn.ensemble.AdaBoostClassifier.
Przykład realizacji
W poniższym przykładzie tworzymy regresor AdaBoost przy użyciu sklearn.ensemble.AdaBoostregressor a także przewidywanie nowych wartości za pomocą metody Predict ().
from sklearn.ensemble import AdaBoostRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 10, n_informative = 2,random_state = 0, shuffle = False)
ADBregr = RandomForestRegressor(random_state = 0,n_estimators = 100)
ADBregr.fit(X, y)Wynik
AdaBoostRegressor(base_estimator = None, learning_rate = 1.0, loss = 'linear',
n_estimators = 100, random_state = 0)Przykład
Po dopasowaniu możemy przewidzieć na podstawie modelu regresji w następujący sposób -
print(ADBregr.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))Wynik
[85.50955817]Wzmocnienie drzewa gradientowego
Nazywa się to również Gradient Boosted Regression Trees(GRBT). Jest to w zasadzie uogólnienie wzmacniania do dowolnych różniczkowalnych funkcji straty. Tworzy model predykcyjny w postaci zestawu modeli prognozowania tygodniowego. Może być używany do problemów z regresją i klasyfikacją. Ich główna zaleta polega na tym, że w naturalny sposób radzą sobie z danymi typu mieszanego.
Klasyfikacja z Gradient Tree Boost
Do tworzenia klasyfikatora Gradient Tree Boost służy moduł Scikit-learning sklearn.ensemble.GradientBoostingClassifier. Podczas budowania tego klasyfikatora głównym parametrem używanym przez ten moduł jest „strata”. Tutaj „strata” jest wartością funkcji straty, która ma być zoptymalizowana. Jeśli wybierzemy strata = odchylenie, odnosi się to do odchylenia do klasyfikacji z probabilistycznymi wynikami.
Z drugiej strony, jeśli ustawimy wartość tego parametru na wykładniczą, wówczas odzyskuje on algorytm AdaBoost. Parametrn_estimatorsbędzie kontrolować liczbę uczniów w tygodniu. Hyper-parametr o nazwielearning_rate (w zakresie (0.0, 1.0]) będzie kontrolować nadmierne dopasowanie poprzez skurcz.
Przykład realizacji
W poniższym przykładzie tworzymy klasyfikator Gradient Boosting przy użyciu sklearn.ensemble.GradientBoostingClassifier. Dopasowujemy ten klasyfikator do 50-tygodniowych uczniów.
from sklearn.datasets import make_hastie_10_2
from sklearn.ensemble import GradientBoostingClassifier
X, y = make_hastie_10_2(random_state = 0)
X_train, X_test = X[:5000], X[5000:]
y_train, y_test = y[:5000], y[5000:]
GDBclf = GradientBoostingClassifier(n_estimators = 50, learning_rate = 1.0,max_depth = 1, random_state = 0).fit(X_train, y_train)
GDBclf.score(X_test, y_test)Wynik
0.8724285714285714Przykład
Możemy również użyć zestawu danych sklearn do zbudowania klasyfikatora przy użyciu klasyfikatora zwiększającego gradient. Jak w poniższym przykładzie używamy zestawu danych Pima-Indian.
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names = headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
seed = 5
kfold = KFold(n_splits = 10, random_state = seed)
num_trees = 100
max_features = 5
ADBclf = GradientBoostingClassifier(n_estimators = num_trees, max_features = max_features)
results = cross_val_score(ADBclf, X, Y, cv = kfold)
print(results.mean())Wynik
0.7946582356674234Regresja z Gradient Tree Boost
Do tworzenia regresora z metodą Gradient Tree Boost służy biblioteka Scikit-Learn sklearn.ensemble.GradientBoostingRegressor. Może określić funkcję utraty dla regresji poprzez nazwę parametru utraty. Domyślna wartość straty to „ls”.
Przykład realizacji
W poniższym przykładzie tworzymy regresor zwiększania gradientu przy użyciu sklearn.ensemble.GradientBoostingregressor a także znajdowanie błędu średniokwadratowego za pomocą metody mean_squared_error ().
import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_friedman1
from sklearn.ensemble import GradientBoostingRegressor
X, y = make_friedman1(n_samples = 2000, random_state = 0, noise = 1.0)
X_train, X_test = X[:1000], X[1000:]
y_train, y_test = y[:1000], y[1000:]
GDBreg = GradientBoostingRegressor(n_estimators = 80, learning_rate=0.1,
max_depth = 1, random_state = 0, loss = 'ls').fit(X_train, y_train)Po dopasowaniu możemy znaleźć średni kwadratowy błąd w następujący sposób -
mean_squared_error(y_test, GDBreg.predict(X_test))Wynik
5.391246106657164Tutaj będziemy studiować metody grupowania w Sklearn, które pomogą w identyfikacji wszelkich podobieństw w próbkach danych.
Metody grupowania, jedna z najbardziej przydatnych nienadzorowanych metod ML, używana do znajdowania wzorców podobieństw i relacji między próbkami danych. Następnie grupują te próbki w grupy wykazujące podobieństwo na podstawie cech. Klastrowanie określa wewnętrzne grupowanie wśród obecnie nieoznaczonych danych, dlatego jest ważne.
Biblioteka Scikit-Learn ma sklearn.clusterdo grupowania danych bez etykiety. W ramach tego modułu scikit-leran mają następujące metody grupowania -
KMeans
Ten algorytm oblicza centroidy i wykonuje iteracje, aż znajdzie optymalną centroidę. Wymaga określenia liczby klastrów, dlatego zakłada, że są one już znane. Główną logiką tego algorytmu jest grupowanie danych rozdzielających próbki w n liczby grup równych wariancji poprzez minimalizację kryteriów zwanych bezwładnością. Liczbę klastrów zidentyfikowanych przez algorytm reprezentuje „K.
Scikit-Learn have sklearn.cluster.KMeansmoduł do wykonywania klastrów K-Means. Podczas obliczania centrów klastrów i wartości bezwładności parametr o nazwiesample_weight pozwala sklearn.cluster.KMeans moduł do przypisywania większej wagi niektórym próbkom.
Propagacja powinowactwa
Algorytm ten opiera się na koncepcji „przekazywania wiadomości” między różnymi parami próbek aż do uzyskania zbieżności. Nie wymaga określenia liczby klastrów przed uruchomieniem algorytmu. Algorytm ma złożoność czasową rzędu (2), co jest jego największą wadą.
Scikit-Learn have sklearn.cluster.AffinityPropagation moduł do wykonywania klastrów Affinity Propagation.
Średnia zmiana
Ten algorytm głównie wykrywa blobsw płynnej gęstości próbek. Przypisuje punkty danych do klastrów iteracyjnie, przesuwając punkty w kierunku największej gęstości punktów danych. Zamiast polegać na parametrze o nazwiebandwidth dyktując rozmiar regionu do przeszukiwania, automatycznie ustawia liczbę klastrów.
Scikit-Learn have sklearn.cluster.MeanShift moduł do wykonywania grupowania Mean Shift.
Grupowanie widmowe
Przed grupowaniem algorytm ten zasadniczo wykorzystuje wartości własne, tj. Widmo macierzy podobieństwa danych, aby przeprowadzić redukcję wymiarowości w mniejszej liczbie wymiarów. Stosowanie tego algorytmu nie jest zalecane w przypadku dużej liczby klastrów.
Scikit-Learn have sklearn.cluster.SpectralClustering moduł do wykonywania klastrowania spektralnego.
Klastrowanie hierarchiczne
Ten algorytm buduje zagnieżdżone klastry poprzez sukcesywne łączenie lub dzielenie klastrów. Ta hierarchia klastrów jest reprezentowana jako dendrogram, czyli drzewo. Dzieli się na dwie kategorie -
Agglomerative hierarchical algorithms- W tego rodzaju hierarchicznym algorytmie każdy punkt danych jest traktowany jak pojedynczy klaster. Następnie sukcesywnie aglomeruje pary klastrów. Wykorzystuje to podejście oddolne.
Divisive hierarchical algorithms- W tym hierarchicznym algorytmie wszystkie punkty danych są traktowane jako jeden duży klaster. W tym przypadku proces tworzenia klastrów polega na podzieleniu, z zastosowaniem podejścia odgórnego, jednego dużego klastra na różne małe klastry.
Scikit-Learn have sklearn.cluster.AgglomerativeClustering moduł do wykonywania klastrów aglomeracyjnych hierarchicznych.
DBSCAN
To znaczy “Density-based spatial clustering of applications with noise”. Algorytm ten opiera się na intuicyjnym pojęciu „klastrów” i „szumu”, zgodnie z którym klastry to gęste obszary o mniejszej gęstości w przestrzeni danych, oddzielone obszarami punktów danych o mniejszej gęstości.
Scikit-Learn have sklearn.cluster.DBSCANmoduł do wykonywania klastrów DBSCAN. Istnieją dwa ważne parametry, mianowicie min_samples i eps używane przez ten algorytm do definiowania gęstości.
Wyższa wartość parametru min_samples lub niższa wartość parametru eps będzie wskazywać na większą gęstość punktów danych, która jest niezbędna do utworzenia klastra.
OPTYKA
To znaczy “Ordering points to identify the clustering structure”. Algorytm ten znajduje również klastry oparte na gęstości w danych przestrzennych. Jego podstawowa logika działania jest podobna do DBSCAN.
Rozwiązuje główną słabość algorytmu DBSCAN - problem wykrywania znaczących klastrów w danych o różnej gęstości - poprzez uporządkowanie punktów bazy danych w taki sposób, że najbliższe przestrzennie punkty stają się sąsiadami w kolejności.
Scikit-Learn have sklearn.cluster.OPTICS moduł do wykonywania klastrowania OPTICS.
BRZOZOWY
To oznacza zrównoważoną redukcję iteracyjną i grupowanie przy użyciu hierarchii. Służy do hierarchicznego grupowania dużych zbiorów danych. Buduje drzewo o nazwieCFT to znaczy Characteristics Feature Treedla podanych danych.
Zaletą CFT jest to, że węzły danych zwane węzłami CF (cecha charakterystyczna) przechowują informacje niezbędne do tworzenia klastrów, co dodatkowo zapobiega konieczności przechowywania w pamięci całych danych wejściowych.
Scikit-Learn have sklearn.cluster.Birch moduł do wykonywania klastrowania BIRCH.
Porównanie algorytmów klastrowania
Poniższa tabela przedstawia porównanie (na podstawie parametrów, skalowalności i metryki) algorytmów grupowania w scikit-learn.
| Sr.No | Nazwa algorytmu | Parametry | Skalowalność | Metric używany |
|---|---|---|---|---|
| 1 | K-średnie | Liczba klastrów | Bardzo duże n_samples | Odległość między punktami. |
| 2 | Propagacja powinowactwa | Tłumienie | Nie można go skalować za pomocą n_samples | Odległość wykresu |
| 3 | Zmiana średniej | Pasmo | Nie można go skalować za pomocą n_samples. | Odległość między punktami. |
| 4 | Grupowanie widmowe | Liczba klastrów | Średni poziom skalowalności z n_samples. Mały poziom skalowalności dzięki n_clusters. | Odległość wykresu |
| 5 | Klastrowanie hierarchiczne | Próg odległości lub liczba klastrów | Duże n_samples Duże n_clusters | Odległość między punktami. |
| 6 | DBSCAN | Wielkość okolicy | Bardzo duże n_samples i średnie n_clusters. | Odległość do najbliższego punktu |
| 7 | OPTYKA | Minimalne członkostwo w klastrze | Bardzo duże n_samples i duże n_clusters. | Odległość między punktami. |
| 8 | BRZOZOWY | Próg, współczynnik rozgałęzienia | Duże n_samples Duże n_clusters | Odległość euklidesowa między punktami. |
Grupowanie K-średnich w zestawie danych Scikit-Learn Digit
W tym przykładzie zastosujemy grupowanie K-średnich na zbiorze danych cyfr. Ten algorytm zidentyfikuje podobne cyfry bez korzystania z oryginalnych informacji na etykiecie. Wdrożenie odbywa się na notebooku Jupyter.
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shapeWynik
1797, 64)Te dane wyjściowe pokazują, że cyfrowy zbiór danych zawiera 1797 próbek z 64 funkcjami.
Przykład
Teraz wykonaj grupowanie K-średnich w następujący sposób -
kmeans = KMeans(n_clusters = 10, random_state = 0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shapeWynik
(10, 64)Te dane wyjściowe pokazują, że grupowanie K-średnich utworzyło 10 klastrów z 64 funkcjami.
Przykład
fig, ax = plt.subplots(2, 5, figsize = (8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks = [], yticks = [])
axi.imshow(center, interpolation = 'nearest', cmap = plt.cm.binary)Wynik
Poniższe dane wyjściowe zawierają obrazy pokazujące centra klastrów poznane przez grupowanie K-średnich.
Następnie poniższy skrypt Pythona dopasuje wyuczone etykiety klastrów (według K-średnich) do prawdziwych etykiet w nich znalezionych -
from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
mask = (clusters == i)
labels[mask] = mode(digits.target[mask])[0]Możemy również sprawdzić dokładność za pomocą poniższego polecenia.
from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)Wynik
0.7935447968836951Pełny przykład implementacji
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape
kmeans = KMeans(n_clusters = 10, random_state = 0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape
fig, ax = plt.subplots(2, 5, figsize = (8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks=[], yticks = [])
axi.imshow(center, interpolation = 'nearest', cmap = plt.cm.binary)
from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
mask = (clusters == i)
labels[mask] = mode(digits.target[mask])[0]
from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)Istnieją różne funkcje, za pomocą których możemy ocenić wydajność algorytmów klastrowania.
Poniżej przedstawiono kilka ważnych i najczęściej używanych funkcji udostępnianych przez Scikit-learn do oceny wydajności klastrowania -
Skorygowany indeks Rand
Rand Index to funkcja obliczająca miarę podobieństwa między dwoma grupowaniami. W przypadku tego obliczenia indeks rand uwzględnia wszystkie pary próbek i pary zliczania, które są przypisane do podobnych lub różnych klastrów w przewidywanym i rzeczywistym skupianiu. Następnie surowy wynik indeksu Rand jest `` dostosowywany do przypadku '' do wyniku skorygowanego indeksu Rand przy użyciu następującego wzoru -
$$Adjusted\:RI=\left(RI-Expected_{-}RI\right)/\left(max\left(RI\right)-Expected_{-}RI\right)$$Ma dwa parametry, a mianowicie labels_true, które są etykietami klas naziemnych, i labels_pred, które są etykietami klastrów do oceny.
Przykład
from sklearn.metrics.cluster import adjusted_rand_score
labels_true = [0, 0, 1, 1, 1, 1]
labels_pred = [0, 0, 2, 2, 3, 3]
adjusted_rand_score(labels_true, labels_pred)Wynik
0.4444444444444445Idealne oznakowanie otrzyma ocenę 1, a złe lub niezależne oznaczenie - 0 lub wynik negatywny.
Ocena oparta na wzajemnych informacjach
Informacje wzajemne to funkcja obliczająca zgodność dwóch przydziałów. Ignoruje permutacje. Dostępne są następujące wersje -
Znormalizowane informacje wzajemne (NMI)
Scikit uczyć się mieć sklearn.metrics.normalized_mutual_info_score moduł.
Przykład
from sklearn.metrics.cluster import normalized_mutual_info_score
labels_true = [0, 0, 1, 1, 1, 1]
labels_pred = [0, 0, 2, 2, 3, 3]
normalized_mutual_info_score (labels_true, labels_pred)Wynik
0.7611702597222881Skorygowane informacje wzajemne (AMI)
Scikit uczyć się mieć sklearn.metrics.adjusted_mutual_info_score moduł.
Przykład
from sklearn.metrics.cluster import adjusted_mutual_info_score
labels_true = [0, 0, 1, 1, 1, 1]
labels_pred = [0, 0, 2, 2, 3, 3]
adjusted_mutual_info_score (labels_true, labels_pred)Wynik
0.4444444444444448Punktacja Fowlkes-Mallows
Funkcja Fowlkesa-Mallowsa mierzy podobieństwo dwóch skupień zbioru punktów. Można ją zdefiniować jako średnią geometryczną parami precyzji i pamięci.
Matematycznie,
$$FMS=\frac{TP}{\sqrt{\left(TP+FP\right)\left(TP+FN\right)}}$$Tutaj, TP = True Positive - liczba par punktów należących do tych samych klastrów zarówno w prawdziwych, jak i przewidywanych etykietach.
FP = False Positive - liczba par punktów należących do tych samych klastrów w prawdziwych etykietach, ale nie w przewidywanych etykietach.
FN = False Negative - liczba par punktów należących do tych samych klastrów w przewidywanych etykietach, ale nie w prawdziwych etykietach.
Scikit Learn ma moduł sklearn.metrics.fowlkes_mallows_score -
Przykład
from sklearn.metrics.cluster import fowlkes_mallows_score
labels_true = [0, 0, 1, 1, 1, 1]
labels_pred = [0, 0, 2, 2, 3, 3]
fowlkes_mallows__score (labels_true, labels_pred)Wynik
0.6546536707079771Współczynnik sylwetki
Funkcja Silhouette obliczy średni współczynnik sylwetki wszystkich próbek przy użyciu średniej odległości wewnątrz klastra i średniej odległości najbliższego klastra dla każdej próbki.
Matematycznie,
$$S=\left(b-a\right)/max\left(a,b\right)$$Tutaj a jest odległością wewnątrz klastra.
a b oznacza średnią odległość do najbliższego klastra.
Scikit uczyć się mieć sklearn.metrics.silhouette_score moduł -
Przykład
from sklearn import metrics.silhouette_score
from sklearn.metrics import pairwise_distances
from sklearn import datasets
import numpy as np
from sklearn.cluster import KMeans
dataset = datasets.load_iris()
X = dataset.data
y = dataset.target
kmeans_model = KMeans(n_clusters = 3, random_state = 1).fit(X)
labels = kmeans_model.labels_
silhouette_score(X, labels, metric = 'euclidean')Wynik
0.5528190123564091Matryca awaryjna
Ta macierz będzie raportować kardynalność przecięcia dla każdej zaufanej pary (prawda, przewidywana). Macierz nieporozumień dla problemów klasyfikacyjnych jest kwadratową macierzą kontyngencji.
Scikit uczyć się mieć sklearn.metrics.contingency_matrix moduł.
Przykład
from sklearn.metrics.cluster import contingency_matrix
x = ["a", "a", "a", "b", "b", "b"]
y = [1, 1, 2, 0, 1, 2]
contingency_matrix(x, y)Wynik
array([
[0, 2, 1],
[1, 1, 1]
])Pierwszy wiersz powyższego wyniku pokazuje, że spośród trzech próbek, których prawdziwy klaster to „a”, żadna z nich nie jest w 0, dwie z nich znajdują się w 1, a 1 w 2. Z drugiej strony, drugi wiersz pokazuje, że spośród trzech próbek którego prawdziwym klastrem jest „b”, 1 należy do 0, 1 do 1, a 1 do 2.
Redukcja wymiarowości, nienadzorowana metoda uczenia maszynowego jest używana do zmniejszania liczby zmiennych cech dla każdej próbki danych, wybierając zestaw głównych cech. Analiza głównych składowych (PCA) to jeden z popularnych algorytmów redukcji wymiarowości.
Dokładne PCA
Principal Component Analysis (PCA) służy do redukcji wymiarowości liniowej za pomocą Singular Value Decomposition(SVD) danych, aby rzutować je na przestrzeń o niższych wymiarach. Podczas dekompozycji przy użyciu PCA dane wejściowe są wyśrodkowane, ale nie skalowane dla każdej funkcji przed zastosowaniem SVD.
Biblioteka Scikit-learn ML zapewnia sklearn.decomposition.PCAmoduł zaimplementowany jako obiekt transformatora, który uczy się n komponentów w swojej metodzie fit (). Można go również używać na nowych danych, aby rzutować je na te komponenty.
Przykład
Poniższy przykład użyje modułu sklearn.decomposition.PCA do znalezienia 5 najlepszych głównych komponentów ze zbioru danych Pima Indians Diabetes.
from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\Users\Leekha\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', ‘class']
dataframe = read_csv(path, names = names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
pca = PCA(n_components = 5)
fit = pca.fit(X)
print(("Explained Variance: %s") % (fit.explained_variance_ratio_))
print(fit.components_)Wynik
Explained Variance: [0.88854663 0.06159078 0.02579012 0.01308614 0.00744094]
[
[-2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-029.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[-2.26488861e-02 -9.72210040e-01 -1.41909330e-01 5.78614699e-029.46266913e-02 -4.69729766e-02 -8.16804621e-04 -1.40168181e-01]
[-2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-012.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]
[-4.90459604e-02 1.19830016e-01 -2.62742788e-01 8.84369380e-01-6.55503615e-02 1.92801728e-01 2.69908637e-03 -3.01024330e-01]
[ 1.51612874e-01 -8.79407680e-02 -2.32165009e-01 2.59973487e-01-1.72312241e-04 2.14744823e-02 1.64080684e-03 9.20504903e-01]
]Przyrostowe PCA
Incremental Principal Component Analysis (IPCA) służy do rozwiązania największego ograniczenia analizy głównych składników (PCA), czyli PCA obsługuje tylko przetwarzanie wsadowe, co oznacza, że wszystkie dane wejściowe do przetworzenia powinny zmieścić się w pamięci.
Biblioteka Scikit-learn ML zapewnia sklearn.decomposition.IPCA moduł, który umożliwia implementację Out-of-Core PCA za pomocą jego partial_fit metoda na sekwencyjnie pobieranych fragmentach danych lub włączając użycie np.memmap, plik mapowany w pamięci, bez ładowania całego pliku do pamięci.
Podobnie jak w przypadku PCA, podczas dekompozycji za pomocą IPCA dane wejściowe są wyśrodkowane, ale nie skalowane dla każdej funkcji przed zastosowaniem SVD.
Przykład
Poniższy przykład użyje sklearn.decomposition.IPCA moduł dotyczący cyfrowego zbioru danych Sklearn.
from sklearn.datasets import load_digits
from sklearn.decomposition import IncrementalPCA
X, _ = load_digits(return_X_y = True)
transformer = IncrementalPCA(n_components = 10, batch_size = 100)
transformer.partial_fit(X[:100, :])
X_transformed = transformer.fit_transform(X)
X_transformed.shapeWynik
(1797, 10)Tutaj możemy częściowo zmieścić się na mniejszych partiach danych (tak jak zrobiliśmy to w przypadku 100 na partię) lub możesz pozwolić fit() funkcja, aby podzielić dane na partie.
Kernel PCA
Kernel Principal Component Analysis, rozszerzenie metody PCA, umożliwia redukcję nieliniowych wymiarów przy użyciu jądra. Obsługuje obatransform and inverse_transform.
Biblioteka Scikit-learn ML zapewnia sklearn.decomposition.KernelPCA moduł.
Przykład
Poniższy przykład użyje sklearn.decomposition.KernelPCAmoduł dotyczący cyfrowego zbioru danych Sklearn. Używamy jądra sigmoidalnego.
from sklearn.datasets import load_digits
from sklearn.decomposition import KernelPCA
X, _ = load_digits(return_X_y = True)
transformer = KernelPCA(n_components = 10, kernel = 'sigmoid')
X_transformed = transformer.fit_transform(X)
X_transformed.shapeWynik
(1797, 10)PCA przy użyciu randomizowanego SVD
Analiza głównych składowych (PCA) przy użyciu randomizowanego SVD jest wykorzystywana do rzutowania danych na przestrzeń o niższych wymiarach, zachowując większość wariancji poprzez usunięcie wektora osobliwego składowych powiązanych z niższymi wartościami osobliwymi. Tutajsklearn.decomposition.PCA moduł z opcjonalnym parametrem svd_solver=’randomized’ będzie bardzo przydatne.
Przykład
Poniższy przykład użyje sklearn.decomposition.PCA moduł z opcjonalnym parametrem svd_solver = 'randomized', aby znaleźć 7 najlepszych głównych komponentów ze zbioru danych Pima Indians Diabetes.
from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\Users\Leekha\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names = names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
pca = PCA(n_components = 7,svd_solver = 'randomized')
fit = pca.fit(X)
print(("Explained Variance: %s") % (fit.explained_variance_ratio_))
print(fit.components_)Wynik
Explained Variance: [8.88546635e-01 6.15907837e-02 2.57901189e-02 1.30861374e-027.44093864e-03 3.02614919e-03 5.12444875e-04]
[
[-2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-029.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[-2.26488861e-02 -9.72210040e-01 -1.41909330e-01 5.78614699e-029.46266913e-02 -4.69729766e-02 -8.16804621e-04 -1.40168181e-01]
[-2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-012.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]
[-4.90459604e-02 1.19830016e-01 -2.62742788e-01 8.84369380e-01-6.55503615e-02 1.92801728e-01 2.69908637e-03 -3.01024330e-01]
[ 1.51612874e-01 -8.79407680e-02 -2.32165009e-01 2.59973487e-01-1.72312241e-04 2.14744823e-02 1.64080684e-03 9.20504903e-01]
[-5.04730888e-03 5.07391813e-02 7.56365525e-02 2.21363068e-01-6.13326472e-03 -9.70776708e-01 -2.02903702e-03 -1.51133239e-02]
[ 9.86672995e-01 8.83426114e-04 -1.22975947e-03 -3.76444746e-041.42307394e-03 -2.73046214e-03 -6.34402965e-03 -1.62555343e-01]
]