Jądro Gaussa w uczeniu maszynowym: przykłady metod jądra

Celem tego samouczka jest zapewnienie możliwości liniowego oddzielenia zestawu danych. Samouczek jest podzielony na dwie części:

1. Transformacja funkcji
2. Wytrenuj klasyfikator jądra za pomocą Tensorflow

W pierwszej części poznasz ideę metody jądra w uczeniu maszynowym, aw drugiej zobaczysz, jak wytrenować klasyfikator jądra za pomocą Tensorflow. Będziesz używać zbioru danych dla dorosłych. Celem tego zbioru danych jest sklasyfikowanie przychodów poniżej i powyżej 50 tys., Znając zachowanie każdego gospodarstwa domowego.

W tym samouczku nauczysz się:

• Dlaczego potrzebujesz metod jądra?
• Co to jest jądro w uczeniu maszynowym?
• Rodzaje metod jądra
• Trenuj klasyfikator jądra Gaussa za pomocą TensorFlow

Dlaczego potrzebujesz metod jądra?

Celem każdego klasyfikatora jest prawidłowe przewidywanie klas. W tym celu zbiór danych powinien być możliwy do rozdzielenia. Spójrz na poniższy wykres; dość łatwo zauważyć, że wszystkie punkty powyżej czarnej linii należą do pierwszej klasy, a pozostałe do drugiej. Jednak zestaw danych tak prosty jest niezwykle rzadki. W większości przypadków danych nie można rozdzielić. Metody jądra w uczeniu maszynowym utrudniają naiwne klasyfikatory, takie jak regresja logistyczna.

import numpy as npimport matplotlib.pyplot as pltfrom 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 wykreślamy zbiór danych, którego nie można rozdzielić liniowo. Jeśli narysujemy linię prostą, większość punktów nie zostanie zaliczona do właściwej klasy.

Jednym ze sposobów rozwiązania tego problemu jest pobranie zestawu danych i przekształcenie danych w inną mapę obiektów. Oznacza to, że użyjesz funkcji do przekształcenia danych w innym planie, 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 są w planie jądra Gaussa 2D, którego nie można rozdzielić. Możesz spróbować przekształcić te dane w trzech wymiarach, czyli stworzyć figurę z 3 osiami.

W naszym przykładzie jądra Gaussa zastosujemy mapowanie wielomianowe, aby przenieść nasze dane do wymiaru 3D. Formuła przekształcania danych jest następująca.

Definiujesz funkcję w Gaussian Kernel Python, aby utworzyć nowe mapy funkcji

Możesz użyć numpy do zakodowania powyższej formuły:

Formuła	Odpowiednik Numpy Code
x	x [:, 0] **
y	x [:, 1]
x 2	x [:, 0] ** 2
	np.sqrt (2) *
xy	x [:, 0] * x [:, 1]
y 2	x [:, 1] ** 2

### illustration purposedef mapping(x, y):x = np.c_[(x, y)]if len(x) > 2:x_1 = x[:,0]**2x_2 = np.sqrt(2)*x[:,0]*x[:,1]x_3 = x[:,1]**2else:x_1 = x[0]**2x_2 = np.sqrt(2)*x[0]*x[1]x_3 = x[1]**2trans_x = np.array([x_1, x_2, x_3])return trans_x

Nowe odwzorowanie powinno mieć 3 wymiary z 16 punktami

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Zróbmy nowy wykres z odpowiednio 3 osiami, x, y i z.

# plotfig = 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, jasne jest, że zbiór danych można teraz rozdzielić

# plotfig = 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 będziesz musiał utworzyć więcej niż 2 wymiary, napotkasz duży problem przy użyciu powyższej metody. W rzeczywistości musisz przekształcić wszystkie punkty danych, co jest oczywiście nie do utrzymania. Zajmie ci to całe wieki, a komputerowi może zabraknąć pamięci.

Najczęstszym sposobem rozwiązania tego problemu jest użycie jądra .

Co to jest jądro w uczeniu maszynowym?

Chodzi o to, aby użyć przestrzeni cech o wyższym wymiarze, aby dane były prawie liniowo rozdzielane, jak pokazano na powyższym rysunku.

Istnieje wiele wyższych przestrzeni wymiarowych, które umożliwiają rozdzielenie punktów danych. Na przykład pokazaliśmy, że mapowanie wielomianów to świetny początek.

Wykazaliśmy również, że przy dużej ilości danych transformacja ta nie jest wydajna. Zamiast tego można użyć funkcji jądra w uczeniu maszynowym, aby zmodyfikować dane bez przechodzenia do nowego planu funkcji.

Magia jądra polega na znalezieniu funkcji, która pozwala uniknąć wszystkich problemów wynikających z obliczeń wielowymiarowych. Wynikiem jądra jest skalar, lub inaczej mówiąc, jesteśmy z powrotem w jednowymiarowej przestrzeni

Po znalezieniu tej funkcji możesz ją podłączyć do standardowego klasyfikatora liniowego.

Zobaczmy przykład, aby zrozumieć koncepcję uczenia maszynowego jądra. Masz dwa wektory, x1 i x2. Celem jest stworzenie wyższego wymiaru za pomocą mapowania wielomianowego. Wynik jest równy iloczynowi skalarnemu nowej mapy obiektów. Z powyższej metody musisz:

1. Przekształć x1 i x2 w nowy wymiar
2. Oblicz iloczyn skalarny: wspólny dla wszystkich jąder
3. Przekształć x1 i x2 w nowy wymiar

Możesz użyć funkcji utworzonej powyżej, aby obliczyć wyższy wymiar.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1) 

Wynik

[[ 9. 100. ][ 25.45584412 141.42135624][ 36. 100. ]] 

Oblicz iloczyn skalarny

Możesz użyć kropki obiektu z numpy, aby obliczyć iloczyn skalarny między pierwszym a drugim wektorem przechowywanym w x_1.

print(np.dot(x_1[:,0], x_1[:,1]))8100.0 

Wynik to 8100. Widzisz problem, musisz zapisać w pamięci nową mapę funkcji, aby obliczyć iloczyn skalarny. Jeśli masz zbiór danych z milionami rekordów, jest on nieefektywny pod względem obliczeniowym.

Zamiast tego można użyć jądra wielomianu do obliczenia iloczynu skalarnego bez przekształcania wektora. Ta funkcja oblicza iloczyn skalarny x1 i x2, tak jakby te dwa wektory zostały przekształcone do wyższego wymiaru. Mówiąc inaczej, funkcja jądra oblicza wyniki iloczynu skalarnego z innej przestrzeni cech.

Możesz napisać wielomianową funkcję jądra w Pythonie w następujący sposób.

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. Wynik jest równy drugiej metodzie. To jest magia jądra.

polynomial_kernel(x1, x2, p=2)8100 

Rodzaje metod jądra

Dostępnych jest wiele różnych technik jądra. Najprostszym jest jądro liniowe. Ta funkcja działa całkiem dobrze przy klasyfikacji tekstu. Drugie jądro to:

• Jądro wielomianowe
• Jądro Gaussa

W przykładzie z TensorFlow użyjemy Random Fouriera. TensorFlow ma wbudowany estymator do obliczania nowej przestrzeni funkcji. Funkcja filtru Gaussa jest przybliżeniem funkcji jądra Gaussa.

Funkcja filtrowania Gaussa oblicza podobieństwo między punktami danych w znacznie większej przestrzeni wymiarowej.

Trenuj klasyfikator jądra Gaussa za pomocą TensorFlow

Celem algorytmu jest sklasyfikowanie gospodarstwa domowego zarabiającego więcej lub mniej niż 50 tys.

Ocenisz logistyczne uczenie maszynowe regresji jądra, aby mieć model porównawczy. Następnie wytrenujesz 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 robocza
• fnlwgt
• Edukacja
• edukacja_num
• małżeński
• zawód
• związek
• wyścig
• seks
• zysk kapitałowy
• capital_loss
• hours_week
• ojczyźnie
• etykieta

Przed wytrenowaniem i oceną modelu postępujesz zgodnie z poniższymi wskazówkami:

• 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) Zaimportuj biblioteki

Aby zaimportować i wytrenować modele jądra w sztucznej inteligencji, musisz zaimportować tensorflow, pandy i numpy

#import numpy as npfrom sklearn.model_selectionimport train_test_splitimport tensorflow as tfimport pandas as pdimport numpy as np

Krok 2) Zaimportuj dane

Pobierasz dane z poniższej witryny internetowej i importujesz je jako ramkę danych pandy.

## Define path dataCOLUMNS = ['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"## Importdf_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 pociąg i zestaw testowy są zdefiniowane, możesz zmienić etykietę kolumny z łańcucha 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

Zestaw danych zawiera zarówno cechy ciągłe, jak i kategorialne. Dobrą praktyką jest standaryzacja wartości zmiennych ciągłych. Możesz użyć funkcji StandardScaler z Sci-Kit Learn. Tworzysz również funkcję zdefiniowaną przez użytkownika, aby ułatwić konwersję pociągu i zestawu testowego. Zwróć uwagę, że łączysz zmienne ciągłe i kategorialne ze wspólnym zestawem 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 StandardScalerfrom sklearn import preprocessingdef 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żesz przekonwertować zestaw 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ą. Da ci to podstawową dokładność. Celem jest pokonanie linii bazowej za pomocą innego algorytmu, a mianowicie klasyfikatora jądra.

Krok 4) Skonstruuj model logistyczny: Model bazowy

Kolumnę funkcji tworzy się za pomocą obiektu real_valued_column. Zapewni to, że wszystkie zmienne są gęstymi danymi liczbowymi.

feat_column = tf.contrib.layers.real_valued_column('features', dimension=14) 

Estymator jest definiowany za pomocą TensorFlow Estimator, a Ty instruujesz kolumny funkcji i gdzie zapisać wykres.

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': , '_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 modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_train},y=y_train,batch_size=200,num_epochs=None,shuffle=True) 

Możesz trenować model 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 = 1INFO:tensorflow:global_step/sec: 324.16INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)INFO:tensorflow:global_step/sec: 267.092INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)INFO:tensorflow:global_step/sec: 292.679INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)INFO:tensorflow:global_step/sec: 225.582INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)INFO:tensorflow:global_step/sec: 209.975INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)INFO:tensorflow:global_step/sec: 241.648INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)INFO:tensorflow:global_step/sec: 305.193INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)INFO:tensorflow:global_step/sec: 396.295INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)INFO:tensorflow:global_step/sec: 359.857INFO: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.

Krok 6) Oceń model

Definiujesz estymator numpy do oceny modelu. Używasz całego zbioru danych do oceny

# Evaluationtest_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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000INFO: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:23INFO: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ść 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.

Do uczenia klasyfikatora jądra potrzebne są dwa predefiniowane estymatory dostępne w TensorFlow:

• RandomFourierFeatureMapper
• KernelLinearClassifier

W pierwszej sekcji dowiedziałeś się, że musisz przekształcić niski wymiar w wysoki wymiar za pomocą funkcji jądra. Dokładniej, użyjesz Random Fourier, który jest przybliżeniem funkcji Gaussa. Na szczęście Tensorflow ma w swojej bibliotece funkcję: RandomFourierFeatureMapper. Model można wytrenować za pomocą estymatora KernelLinearClassifier.

Aby zbudować model, wykonaj następujące kroki:

1. Ustaw funkcję jądra wysokiego wymiaru
2. Ustaw hiperparametr L2
3. Zbuduj model
4. Wytrenuj model
5. 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 5000-wymiarowego wektora. Używasz losowych cech Fouriera do osiągnięcia transformacji. Jeśli przypomnisz sobie wzór jądra Gaussa, zauważysz, że należy zdefiniować parametr odchylenia standardowego. Ten parametr kontroluje miarę podobieństwa wykorzystywaną podczas klasyfikacji.

Możesz dostroić wszystkie parametry w RandomFourierFeatureMapper za pomocą:

• input_dim = 14
• output_dim = 5000
• stddev = 4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm') 

Musisz skonstruować program odwzorowujący jądro, używając kolumn cech utworzonych wcześniej: feat_column

### Map Kernelkernel_mappers = {feat_column: [kernel_mapper]} 

Krok B) Ustaw hiperparametr L2

Aby zapobiec nadmiernemu dopasowaniu, karasz funkcję utraty za pomocą regulatora 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. Zauważ, że dodajesz program odwzorowujący jądro zdefiniowany wcześniej i zmieniasz katalog modelu.

### Prep estimatorestimator_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': , '_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) Wytrenuj model

Teraz, gdy klasyfikator jądra jest już zbudowany, możesz go wytrenować. Decydujesz się powtórzyć model 2000 razy

### estimateestimator_kernel.fit(input_fn=train_input_fn, steps=2000)

WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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 = 1INFO:tensorflow:global_step/sec: 86.6365INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)INFO:tensorflow:global_step/sec: 80.1986INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)INFO:tensorflow:global_step/sec: 79.6376INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)INFO:tensorflow:global_step/sec: 95.8442INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)INFO:tensorflow:global_step/sec: 93.7799INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)INFO:tensorflow:global_step/sec: 94.7071INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)INFO:tensorflow:global_step/sec: 90.7402INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)INFO:tensorflow:global_step/sec: 94.4924INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)INFO:tensorflow:global_step/sec: 95.3472INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)INFO:tensorflow:global_step/sec: 97.2928INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)INFO:tensorflow:global_step/sec: 85.6761INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)INFO:tensorflow:global_step/sec: 91.4194INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)INFO:tensorflow:global_step/sec: 82.5954INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)INFO:tensorflow:global_step/sec: 89.8748INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)INFO:tensorflow:global_step/sec: 76.9761INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)INFO:tensorflow:global_step/sec: 73.7192INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)INFO:tensorflow:global_step/sec: 83.0573INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)INFO:tensorflow:global_step/sec: 71.7029INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)INFO:tensorflow:global_step/sec: 73.2663INFO: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': , 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': , 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): []}}) 

Krok E) Oceń model

Wreszcie, oceniasz wydajność swojego modelu. Powinieneś być w stanie pokonać regres logistyczny.

# Evaluate and report metrics.eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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:50INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000INFO: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:51INFO: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%, to 2% poprawa w porównaniu z regresją logistyczną. Istnieje kompromis między poprawą dokładności a kosztem obliczeniowym. Musisz się zastanowić, czy poprawa o 2% jest warta czasu spędzonego przez inny klasyfikator i czy ma przekonujący wpływ na Twój biznes.

Podsumowanie

Jądro to świetne narzędzie do przekształcania danych nieliniowych w (prawie) liniowe. Wadą tej metody jest to, że jest ona czasochłonna obliczeniowo i kosztowna.

Poniżej znajduje się najważniejszy kod do szkolenia klasyfikatora jądra

Ustaw funkcję jądra wysokiego wymiaru

• input_dim = 14
• output_dim = 5000
• stddev = 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") 

Wytrenuj 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)