Jądro Gaussa w uczeniu maszynowym: Python Metody jądra
Celem tego samouczka jest zapewnienie liniowej separacji zbioru danych. Tutorial jest podzielony na dwie części:
- Transformacja funkcji
- Trenuj klasyfikator jądra za pomocą Tensorflow
W pierwszej części zrozumiesz ideę stojącą za metodą Kernel w uczeniu maszynowym, a w drugiej części zobaczysz, jak trenować klasyfikator kernela za pomocą Tensorflow. Użyjesz zestawu danych dla dorosłych. Celem tego zestawu danych jest klasyfikacja przychodów poniżej i powyżej 50 tys., znając zachowanie każdego gospodarstwa domowego.
Dlaczego potrzebujesz metod jądra?
Celem każdego klasyfikatora jest prawidłowe przewidzenie klas. W tym celu zbiór danych powinien być rozdzielny. Spójrz na poniższy wykres; dość łatwo jest zauważyć, że wszystkie punkty powyżej czarnej linii należą do pierwszej klasy, a pozostałe punkty do drugiej klasy. Jednak niezwykle rzadko zdarza się, aby zbiór danych był tak prosty. W większości przypadków danych nie można rozdzielić. Metody jądra w uczeniu maszynowym sprawiają, że naiwne klasyfikatory, takie jak regresja logistyczna, są trudne.
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
x_lin = np.array([1,2,3,4,5,6,7,8,9,10]) y_lin = np.array([2,2,3,2,2,9,6,8,8,9]) label_lin = np.array([0,0,0,0,0,1,1,1,1,1]) fig = plt.figure() ax=fig.add_subplot(111) plt.scatter(x_lin, y_lin, c=label_lin, s=60) plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2) ax.set_xlim([-5,15]) ax.set_ylim([-5,15])plt.show()
Na poniższym rysunku przedstawiamy zbiór danych, którego nie można liniowo oddzielić. Jeśli poprowadzimy linię prostą, większość punktów nie zostanie zaliczona do właściwej klasy.
Jednym ze sposobów rozwiązania tego problemu jest pobranie zbioru danych i przekształcenie go w inną mapę obiektów. Oznacza to, że użyjesz funkcji do przekształcenia danych w inny plan, który powinien być liniowy.
x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18]) y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1]) label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1])
fig = plt.figure() plt.scatter(x, y, c=label, s=60) plt.show()
Dane z powyższego rysunku znajdują się w dwuwymiarowym planie jądra Gaussa, którego nie można rozdzielić. Możesz spróbować przekształcić te dane w trójwymiarowy, to znaczy stworzyć figurę o 2 osiach.
W naszym przykładzie jądra Gaussa zastosujemy mapowanie wielomianowe, aby przenieść nasze dane do wymiaru 3D. Formuła transformacji danych jest następująca.
Definiujesz funkcję w jądrze Gaussa Python do tworzenia nowych map obiektów
Możesz użyć tępy zakodować powyższą formułę:
Formuła | Równoważny kod Numpy |
---|---|
x | x[:,0]** |
y | x[:,1] |
x2 | x[:,0]**2 |
np.sqrt(2)* | |
xy | x[:,0]*x[:,1] |
y2 | x[:,1]**2 |
### illustration purpose def mapping(x, y): x = np.c_[(x, y)] if len(x) > 2: x_1 = x[:,0]**2 x_2 = np.sqrt(2)*x[:,0]*x[:,1] x_3 = x[:,1]**2 else: x_1 = x[0]**2 x_2 = np.sqrt(2)*x[0]*x[1] x_3 = x[1]**2 trans_x = np.array([x_1, x_2, x_3]) return trans_x
Nowe mapowanie powinno mieć 3 wymiary i 16 punktów
x_1 = mapping(x, y) x_1.shape
(3, 16)
Stwórzmy nowy wykres z 3 osiami, odpowiednio x, y i z.
# plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60) ax.view_init(30, 185)ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label') plt.show()
Widzimy poprawę, ale jeśli zmienimy orientację wykresu, stanie się jasne, że zbiór danych można teraz rozdzielić
# plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60) ax.view_init(0, -180)ax.set_ylim([150,-50]) ax.set_zlim([-10000,10000]) ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label')plt.show()
Aby manipulować dużym zbiorem danych i być może trzeba będzie utworzyć więcej niż 2 wymiary, przy użyciu powyższej metody napotkasz duży problem. W rzeczywistości należy przekształcić wszystkie punkty danych, co wyraźnie nie jest trwałe. Zajmie to wieki, a w komputerze może zabraknąć pamięci.
Najczęstszym sposobem rozwiązania tego problemu jest użycie a jądro.
Czym jest jądro w uczeniu maszynowym?
Pomysł polega na wykorzystaniu przestrzeni cech o wyższym wymiarze, aby dane były niemal liniowo rozdzielone, jak pokazano na powyższym rysunku.
Istnieje wiele przestrzeni o wyższych wymiarach, dzięki którym punkty danych można rozdzielić. Pokazaliśmy na przykład, że mapowanie wielomianów to świetny początek.
Pokazaliśmy również, że przy dużej ilości danych transformacja ta nie jest efektywna. Zamiast tego możesz użyć funkcji jądra w uczeniu maszynowym, aby zmodyfikować dane bez zmiany planu funkcji na nowy.
Magia jądra polega na znalezieniu funkcji, która pozwala uniknąć wszelkich problemów wynikających z obliczeń wielowymiarowych. Wynikiem jądra jest skalar lub inaczej mówiąc, wracamy do przestrzeni jednowymiarowej
Po znalezieniu tej funkcji możesz podłączyć ją do standardowego klasyfikatora liniowego.
Zobaczmy przykład, aby zrozumieć koncepcję uczenia maszynowego jądra. Masz dwa wektory, x1 i x2. Celem jest utworzenie wyższego wymiaru za pomocą mapowania wielomianowego. Wynik jest równy iloczynowi skalarnemu nowej mapy obiektów. Z powyższej metody musisz:
- Przekształć x1 i x2 w nowy wymiar
- Oblicz iloczyn skalarny: wspólny dla wszystkich jąder
- Przekształć x1 i x2 w nowy wymiar
Możesz użyć funkcji utworzonej powyżej, aby obliczyć wyższy wymiar.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Wydajność
[[ 9. 100. ] [ 25.45584412 141.42135624] [ 36. 100. ]]
Oblicz iloczyn skalarny
Możesz użyć obiektu dot z numpy, aby obliczyć iloczyn skalarny między pierwszym i drugim wektorem przechowywanym w x_1.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Wynik wynosi 8100. Widzisz problem, musisz przechowywać w pamięci nową mapę obiektów, aby obliczyć iloczyn skalarny. Jeśli masz zbiór danych zawierający miliony rekordów, jest on nieefektywny obliczeniowo.
Zamiast tego możesz użyć jądro wielomianowe obliczyć iloczyn skalarny bez przekształcania wektora. Ta funkcja oblicza iloczyn skalarny x1 i x2 tak, jakby te dwa wektory zostały przekształcone w wyższy wymiar. Inaczej mówiąc, funkcja jądra oblicza wyniki iloczynu skalarnego z innej przestrzeni cech.
Możesz napisać funkcję jądra wielomianu w Python następująco.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Jest to potęga iloczynu skalarnego dwóch wektorów. Poniżej zwracasz drugi stopień jądra wielomianu. Dane wyjściowe są takie same jak w przypadku drugiej metody. Na tym polega magia jądra.
polynomial_kernel(x1, x2, p=2) 8100
Rodzaje metod jądra
Dostępnych jest wiele różnych technik jądra. Najprostsze jest jądro liniowe. Ta funkcja działa całkiem dobrze w przypadku klasyfikacji tekstu. Drugie jądro to:
- Jądro wielomianowe
- Jądro Gaussa
W przykładzie z TensorFlow, użyjemy losowego Fouriera. TensorFlow ma wbudowany estymator do obliczania nowej przestrzeni cech. Funkcja filtru Gaussa jest przybliżeniem funkcji jądra Gaussa.
Funkcja filtrowania Gaussa oblicza podobieństwo między punktami danych w przestrzeni o znacznie wyższych wymiarach.
Trenuj klasyfikator jądra Gaussa za pomocą TensorFlow
Celem algorytmu jest klasyfikacja gospodarstwa domowego zarabiającego powyżej 50 tys.
Ocenisz logistyczne uczenie maszynowe regresji jądra, aby uzyskać model porównawczy. Następnie przeszkolisz klasyfikator jądra, aby sprawdzić, czy możesz uzyskać lepsze wyniki.
Używasz następujących zmiennych ze zbioru danych dla dorosłych:
- wiek
- klasa pracy
- fnlwgt
- Edukacja
- edukacja_num
- małżeński
- zawód
- związek
- wyścig
- seks
- zysk kapitałowy
- strata_kapitału
- godziny_tydzień
- ojczyźnie
- etykieta
Przed wytrenowaniem i oceną modelu postępuj w następujący sposób:
- Krok 1) Zaimportuj biblioteki
- Krok 2) Zaimportuj dane
- Krok 3) Przygotuj dane
- Krok 4) Skonstruuj plik input_fn
- Krok 5) Skonstruuj model logistyczny: Model bazowy
- Krok 6) Oceń model
- Krok 7) Skonstruuj klasyfikator jądra
- Krok 8) Oceń klasyfikator jądra
Krok 1) Importuj biblioteki
Aby importować i trenować modele jądra w Artificial Intelligence, musisz zaimportować tensorflow, pandy i nudny
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Krok 2) Importuj dane
Dane pobierasz z następujących źródeł: Zbieranie danych analitycznych o stronach internetowych lub aplikacjach (aby sprawdzić, czy strona działa poprawnie lub które sekcje strony są najbardziej atrakcyjne dla odwiedzających). i importujesz go jako ramkę danych pandy.
## Define path data COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label'] PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data" PATH_test ="https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test "## Import df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False) df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)
Teraz, gdy zdefiniowano zestaw pociągowy i testowy, możesz zmienić etykietę kolumny z ciągu znaków na liczbę całkowitą. tensorflow nie akceptuje wartości ciągu dla etykiety.
label = {'<=50K': 0,'>50K': 1} df_train.label = [label[item] for item in df_train.label] label_t = {'<=50K.': 0,'>50K.': 1} df_test.label = [label_t[item] for item in df_test.label] df_train.shape (32561, 15)
Krok 3) Przygotuj dane
Zbiór danych zawiera zarówno cechy ciągłe, jak i kategoryczne. Dobrą praktyką jest standaryzacja wartości zmiennych ciągłych. Możesz użyć funkcji StandardScaler z sci-kit Learn. Tworzysz także funkcję zdefiniowaną przez użytkownika, aby ułatwić konwersję zestawu pociągowego i testowego. Pamiętaj, że łączysz zmienne ciągłe i jakościowe we wspólny zbiór danych, a tablica powinna być typu: float32
COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week'] CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country'] from sklearn.preprocessing import StandardScaler from sklearn import preprocessing def prep_data_str(df): scaler = StandardScaler() le = preprocessing.LabelEncoder() df_toscale = df[COLUMNS_INT] df_scaled = scaler.fit_transform(df_toscale.astype(np.float64)) X_1 = df[CATE_FEATURES].apply(le.fit_transform) y = df['label'].astype(np.int32) X_conc = np.c_[df_scaled, X_1].astype(np.float32) return X_conc, y
Funkcja transformatora jest gotowa, można dokonać konwersji zbioru danych i utworzyć funkcję input_fn.
X_train, y_train = prep_data_str(df_train) X_test, y_test = prep_data_str(df_test) print(X_train.shape) (32561, 14)
W następnym kroku będziesz trenować regresję logistyczną. Zapewni to podstawową dokładność. Celem jest pokonanie linii bazowej za pomocą innego algorytmu, a mianowicie klasyfikatora jądra.
Krok 4) Zbuduj model logistyczny: Model bazowy
Konstruujesz kolumnę cech za pomocą obiektu real_valued_column. Dzięki temu wszystkie zmienne będą gęstymi danymi liczbowymi.
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
Estymator jest definiowany za pomocą TensorFlow Estimator, instruujesz kolumny funkcji i miejsce zapisania wykresu.
estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column], n_classes=2, model_dir = "kernel_log" )
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'kernel_log', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a2003f780>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Będziesz trenował regresję logistyczną przy użyciu mini-partii o rozmiarze 200.
# Train the model train_input_fn = tf.estimator.inputs.numpy_input_fn( x={"features": X_train}, y=y_train, batch_size=200, num_epochs=None, shuffle=True)
Model można trenować za pomocą 1.000 iteracji
estimator.train(input_fn=train_input_fn, steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into kernel_log/model.ckpt. INFO:tensorflow:loss = 138.62949, step = 1 INFO:tensorflow:global_step/sec: 324.16 INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec) INFO:tensorflow:global_step/sec: 267.092 INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec) INFO:tensorflow:global_step/sec: 292.679 INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec) INFO:tensorflow:global_step/sec: 225.582 INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec) INFO:tensorflow:global_step/sec: 209.975 INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec) INFO:tensorflow:global_step/sec: 241.648 INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec) INFO:tensorflow:global_step/sec: 305.193 INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec) INFO:tensorflow:global_step/sec: 396.295 INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec) INFO:tensorflow:global_step/sec: 359.857 INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec) INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt. INFO:tensorflow:Loss for final step: 67.79706. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>
Krok 6) Oceń model
Definiujesz estymator numpy do oceny modelu. Do oceny wykorzystujesz cały zbiór danych
# Evaluation test_input_fn = tf.estimator.inputs.numpy_input_fn( x={"features": X_test}, y=y_test, batch_size=16281, num_epochs=1, shuffle=False) estimator.evaluate(input_fn=test_input_fn, steps=1)
INFO:tensorflow:Calling model_fn. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23 INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663, 'accuracy_baseline': 0.76377374, 'auc': 0.84898686, 'auc_precision_recall': 0.67214864, 'average_loss': 0.3877216, 'global_step': 1000, 'label/mean': 0.23622628, 'loss': 6312.495, 'precision': 0.7362797, 'prediction/mean': 0.21208474, 'recall': 0.39417577}
Masz dokładność na poziomie 82 procent. W następnej sekcji spróbujesz pokonać klasyfikator logistyczny klasyfikatorem jądra
Krok 7) Skonstruuj klasyfikator jądra
Estymator jądra nie różni się zbytnio od tradycyjnego klasyfikatora liniowego, przynajmniej pod względem konstrukcji. Pomysł polega na wykorzystaniu mocy jawnego jądra z klasyfikatorem liniowym.
Aby wytrenować klasyfikator jądra, potrzebujesz dwóch predefiniowanych estymatorów dostępnych w TensorFlow:
- RandomFourierFeatureMapper
- Klasyfikator liniowy jądra
Z pierwszej sekcji dowiedziałeś się, że musisz przekształcić niski wymiar w wyższy wymiar za pomocą funkcji jądra. Dokładniej, użyjesz losowego Fouriera, który jest przybliżeniem funkcji Gaussa. Na szczęście Tensorflow ma w swojej bibliotece funkcję: RandomFourierFeatureMapper. Model można trenować za pomocą estymatora KernelLinearClassifier.
Aby zbudować model, wykonaj następujące kroki:
- Ustaw funkcję jądra o dużym wymiarze
- Ustaw hiperparametr L2
- Zbuduj model
- Trenuj model
- Oceń model
Krok A) Ustaw funkcję jądra o dużym wymiarze
Bieżący zbiór danych zawiera 14 cech, które zostaną przekształcone w nowy, wysoki wymiar 5.000-wymiarowego wektora. Aby osiągnąć transformację, używasz losowych funkcji Fouriera. Jeśli przypomnisz sobie wzór jądra Gaussa, zauważysz, że należy zdefiniować parametr odchylenia standardowego. Ten parametr kontroluje miarę podobieństwa stosowaną podczas klasyfikacji.
Możesz dostroić wszystkie parametry w RandomFourierFeatureMapper za pomocą:
- wymiar_wejściowy = 14
- wymiar_wyjściowy= 5000
- stdod=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Musisz skonstruować narzędzie mapujące jądro, korzystając z utworzonych wcześniej kolumn funkcji: feat_column
### Map Kernel kernel_mappers = {feat_column: [kernel_mapper]}
Krok B) Ustaw hiperparametr L2
Aby zapobiec nadmiernemu dopasowaniu, karasz funkcję straty za pomocą regularyzatora L2. Ustawiasz hiperparametr L2 na 0.1, a szybkość uczenia się na 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Krok C) Zbuduj model
Następny krok jest podobny do klasyfikacji liniowej. Używasz wbudowanego estymatora KernelLinearClassifier. Pamiętaj, że dodajesz zdefiniowany wcześniej program odwzorowujący jądro i zmieniasz katalog modelu.
### Prep estimator estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2, optimizer=optimizer, kernel_mappers=kernel_mappers, model_dir="kernel_train")
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version. Instructions for updating: Please switch to tf.contrib.estimator.*_head. WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version. Instructions for updating: Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.* WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version. Instructions for updating: When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead. INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options { per_process_gpu_memory_fraction: 1.0 } , '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}
Krok D) Trenuj model
Teraz, gdy klasyfikator jądra jest już zbudowany, możesz go wytrenować. Decydujesz się na iterację 2000 razy modelu
### estimate estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version. Instructions for updating: When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into kernel_train/model.ckpt. INFO:tensorflow:loss = 0.6931474, step = 1 INFO:tensorflow:global_step/sec: 86.6365 INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec) INFO:tensorflow:global_step/sec: 80.1986 INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec) INFO:tensorflow:global_step/sec: 79.6376 INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec) INFO:tensorflow:global_step/sec: 95.8442 INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec) INFO:tensorflow:global_step/sec: 93.7799 INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec) INFO:tensorflow:global_step/sec: 94.7071 INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec) INFO:tensorflow:global_step/sec: 90.7402 INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec) INFO:tensorflow:global_step/sec: 94.4924 INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec) INFO:tensorflow:global_step/sec: 95.3472 INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec) INFO:tensorflow:global_step/sec: 97.2928 INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec) INFO:tensorflow:global_step/sec: 85.6761 INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec) INFO:tensorflow:global_step/sec: 91.4194 INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec) INFO:tensorflow:global_step/sec: 82.5954 INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec) INFO:tensorflow:global_step/sec: 89.8748 INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec) INFO:tensorflow:global_step/sec: 76.9761 INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec) INFO:tensorflow:global_step/sec: 73.7192 INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec) INFO:tensorflow:global_step/sec: 83.0573 INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec) INFO:tensorflow:global_step/sec: 71.7029 INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec) INFO:tensorflow:global_step/sec: 73.2663 INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec) INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt. INFO:tensorflow:Loss for final step: 0.37795097. KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})
Krok E) Oceń model
Na koniec oceniasz wydajność swojego modelu. Powinieneś być w stanie pokonać regresję logistyczną.
# Evaluate and report metrics. eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:50 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51 INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004
Ostateczna dokładność wynosi 84%, co oznacza poprawę o 2% w porównaniu do regresji logistycznej. Istnieje kompromis pomiędzy poprawą dokładności a kosztami obliczeniowymi. Musisz zastanowić się, czy 2% poprawy jest warte czasu poświęconego na inny klasyfikator i czy ma to przekonujący wpływ na Twój biznes.
Podsumowanie
Jądro jest doskonałym narzędziem do przekształcania danych nieliniowych w (prawie) liniowe. Wadą tej metody jest to, że jest czasochłonna i kosztowna obliczeniowo.
Poniżej znajdziesz najważniejszy kod do szkolenia klasyfikatora jądra
Ustaw funkcję jądra o dużym wymiarze
- wymiar_wejściowy = 14
- wymiar_wyjściowy= 5000
- stdod=4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Ustaw hiperparametr L2
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Zbuduj model
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2, optimizer=optimizer, kernel_mappers=kernel_mappers, model_dir="kernel_train")
Trenuj model
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
Oceń model
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)