Gausa kodols mašīnmācībā: kodola metožu piemēri

Šīs apmācības mērķis ir padarīt datu kopu lineāri atdalāmu. Mācība ir sadalīta divās daļās:

1. Funkcijas pārveidošana
2. Apmāciet kodola klasifikatoru ar Tensorflow

Pirmajā daļā jūs sapratīsit kodola metodes ideju mašīnmācībā, savukārt otrajā daļā redzēsit, kā apmācīt kodola klasifikatoru ar Tensorflow. Jūs izmantosiet pieaugušo datu kopu. Šīs datu kopas mērķis ir klasificēt ieņēmumus zem un virs 50 000, zinot katras mājsaimniecības uzvedību.

Šajā apmācībā jūs uzzināsiet-

• Kāpēc jums ir vajadzīgas kodola metodes?
• Kas ir kodols mašīnmācībā?
• Kodola metožu veidi
• Vilciena Gausa kodola klasifikators ar TensorFlow

Kāpēc jums ir vajadzīgas kodola metodes?

Katra klasifikatora mērķis ir pareizi paredzēt klases. Tāpēc datu kopai jābūt atdalāmai. Paskaties uz zemes gabalu zemāk; ir diezgan vienkārši redzēt, ka visi punkti virs melnās līnijas pieder pirmajai klasei, bet pārējie punkti - otrajai klasei. Tomēr ārkārtīgi reti ir tik vienkārša datu kopa. Vairumā gadījumu dati nav atdalāmi. Kodola metodes mašīnmācībā naiviem klasifikatoriem, piemēram, loģistikas regresijai, sagādā grūtības.

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

Zemāk redzamajā attēlā mēs uzzīmējam datu kopu, kas nav lineāri atdalāma. Ja mēs novilksim taisnu līniju, lielākā daļa punktu netiks klasificēti pareizajā klasē.

Viens no veidiem, kā risināt šo problēmu, ir datu kopas uzņemšana un datu pārveidošana citā funkciju kartē. Tas nozīmē, ka jūs izmantosiet funkciju, lai pārveidotu datus citā plānā, kam jābūt lineāriem.

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

Dati no iepriekš redzamā attēla ir 2D Gausa kodola plānā, kas nav atdalāms. Jūs varat mēģināt pārveidot šos datus trīsdimensijās, tas nozīmē, ka jūs izveidojat skaitli ar 3 asīm.

Mūsu Gausa kodola piemērā mēs izmantosim polinoma kartēšanu, lai mūsu dati nonāktu 3D dimensijā. Datu pārveidošanas formula ir šāda.

Lai izveidotu jauno funkciju kartes, jūs definējat funkciju Gausa kodola Python

Lai kodētu iepriekš minēto formulu, varat izmantot numuru.

Formula	Ekvivalents Numpy kods
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

Jaunajai kartēšanai jābūt ar 3 dimensijām ar 16 punktiem

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Izveidosim jaunu diagrammu ar attiecīgi 3 asīm, x, y un 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() 

Mēs redzam uzlabojumu, taču, ja mainām sižeta orientāciju, ir skaidrs, ka datu kopa tagad ir atdalāma

# 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() 

Lai manipulētu ar lielu datu kopu un jums, iespējams, būs jāizveido vairāk nekā 2 dimensijas, izmantojot iepriekš minēto metodi, jums būs jāsaskaras ar lielu problēmu. Faktiski jums ir jāpārveido visi datu punkti, kas acīmredzami nav ilgtspējīgi. Tas prasīs jums vecumu, un datorā var pietrūkt atmiņas.

Visizplatītākais veids, kā pārvarēt šo problēmu, ir kodola izmantošana .

Kas ir kodols mašīnmācībā?

Ideja ir izmantot augstākas dimensijas objektu telpu, lai datus padarītu gandrīz lineāri atdalāmus, kā parādīts attēlā iepriekš.

Ir daudz augstāku dimensiju atstarpju, lai datu punkti būtu atdalāmi. Piemēram, mēs esam parādījuši, ka polinoma kartēšana ir lielisks sākums.

Mēs arī esam parādījuši, ka, ja ir daudz datu, šī pārveidošana nav efektīva. Tā vietā mašīnmācībā varat izmantot kodola funkciju, lai modificētu datus, nemainot jaunu funkciju plānu.

Kodola burvība ir atrast funkciju, kas ļauj izvairīties no visām nepatikšanām, ko rada augstas dimensijas aprēķins. Kodola rezultāts ir skalārs vai citādi sakot, mēs esam atgriezušies viendimensionālajā telpā

Kad esat atradis šo funkciju, varat to pievienot standarta lineārajam klasifikatoram.

Apskatīsim piemēru, lai izprastu kodola mašīnmācīšanās jēdzienu. Jums ir divi vektori x1 un x2. Mērķis ir izveidot augstāku dimensiju, izmantojot polinoma kartēšanu. Izeja ir vienāda ar jauno objektu kartes punktu punktu. No iepriekš minētās metodes jums:

1. Pārveidojiet x1 un x2 jaunā dimensijā
2. Aprēķiniet punktu punktu: kopīgs visiem kodoliem
3. Pārveidojiet x1 un x2 jaunā dimensijā

Augstākās dimensijas aprēķināšanai varat izmantot iepriekš izveidoto funkciju.

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

Rezultāts

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

Aprēķiniet punktu punktu

Lai aprēķinātu punktu reizinājumu starp pirmo un otro vektorā, kas saglabāts x_1, varat izmantot numpy objekta punktu.

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

Rezultāts ir 8100. Jūs redzat problēmu, jums ir jāglabā atmiņā jauna funkciju karte, lai aprēķinātu punktu produktu. Ja jums ir datu kopa ar miljoniem ierakstu, tā ir skaitļošanas ziņā neefektīva.

Tā vietā jūs varat izmantot polinoma kodolu, lai aprēķinātu punktu reizinājumu, nepārveidojot vektoru. Šī funkcija aprēķina x1 un x2 punktu reizinājumu, it kā šie divi vektori būtu pārveidoti augstākajā dimensijā. Citādi sakot, kodola funkcija aprēķina punktu produkta rezultātus no citas iezīmju vietas.

Polynomial kodola funkciju Python var uzrakstīt šādi.

def polynomial_kernel(x, y, p=2):return (np.dot(x, y)) ** p 

Tas ir divu vektoru punktu reizinājuma spēks. Zemāk jūs atgriezīsit polinoma kodola otro pakāpi. Rezultāts ir vienāds ar citu metodi. Tā ir kodola burvība.

polynomial_kernel(x1, x2, p=2)8100 

Kodola metožu veidi

Ir pieejami daudz dažādu kodola paņēmienu. Vienkāršākais ir lineārais kodols. Šī funkcija diezgan labi darbojas teksta klasifikācijā. Otrs kodols ir:

• Polinoma kodols
• Gausa kodols

Piemērā ar TensorFlow mēs izmantosim Random Fourier. TensorFlow ir izveidots aprēķinātājs, lai aprēķinātu jauno funkciju telpu. Gausa filtra funkcija ir Gausa kodola funkcijas aproksimācija.

Gausa filtrēšanas funkcija aprēķina datu punktu līdzību daudz augstākā dimensiju telpā.

Vilciena Gausa kodola klasifikators ar TensorFlow

Algoritma mērķis ir klasificēt mājsaimniecību, kas nopelna vairāk vai mazāk par 50 000.

Jūs novērtēsiet loģistikas kodola regresijas mašīnmācīšanos, lai iegūtu etalona modeli. Pēc tam jūs apmācīsit kodola klasifikatoru, lai redzētu, vai jūs varat sasniegt labākus rezultātus.

Jūs izmantojat šādus mainīgos no pieaugušo datu kopas:

• vecums
• darba klase
• fnlwgt
• izglītība
• izglītība_num
• laulības
• nodarbošanās
• attiecības
• sacīkstes
• dzimums
• kapitāla pieaugums
• kapitāla zaudējums
• stundas_nedēļa
• dzimtā valsts
• etiķete

Pirms trenējaties un novērtēsit modeli, rīkojieties šādi:

• 1. darbība. Importējiet bibliotēkas
• 2. darbība. Importējiet datus
• 3. solis. Sagatavojiet datus
• 4. solis. Konstruējiet ievades_fn
• 5. solis. Konstruējiet loģistikas modeli: bāzes modelis
• 6. solis) Novērtējiet modeli
• 7. solis. Konstruējiet kodola klasifikatoru
• 8. solis) Novērtējiet kodola klasifikatoru

1. darbība. Importējiet bibliotēkas

Lai importētu un apmācītu kodola modeļus mākslīgajā intelektā, jums jāimportē tensorflow, pandas un numpy

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

2. darbība. Importējiet datus

Jūs lejupielādējat datus no šīs vietnes un importējat tos kā pandas datu ietvaru.

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

Tagad, kad vilciens un testa kopa ir definēta, varat mainīt kolonnas etiķeti no virknes uz veselu skaitli. tensorflow nepieņem etiķetes virknes vērtību.

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)

3. solis. Sagatavojiet datus

Datu kopa satur gan nepārtrauktas, gan kategoriskas pazīmes. Laba prakse ir nepārtraukto mainīgo vērtību standartizēšana. Varat izmantot sci-kit learn funkciju StandardScaler. Jūs arī izveidojat lietotāja definētu funkciju, lai atvieglotu vilciena un testa komplekta konvertēšanu. Ņemiet vērā, ka jūs nepārtrauktos un kategoriskos mainīgos apvienojat kopīgā datu kopā, un masīvam jābūt šāda veida: 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 

Transformatora funkcija ir gatava, jūs varat pārveidot datu kopu un izveidot funkciju 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) 

Nākamajā solī jūs apmācīsit loģistisko regresiju. Tas dos jums pamata precizitāti. Mērķis ir pārspēt bāzes līniju ar citu algoritmu, proti, kodola klasifikatoru.

4. solis. Konstruējiet loģistikas modeli: bāzes modelis

Objektu kolonnu izveidojat ar objektu real_valued_column. Tas nodrošinās, ka visi mainīgie ir blīvi skaitliski dati.

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

Novērtētājs tiek definēts, izmantojot TensorFlow Estimator, jūs norādāt funkciju kolonnas un vietu, kur saglabāt diagrammu.

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} 

Jūs apmācīsit logisitc regresiju, izmantojot mini partijas 200 izmērā.

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

Jūs varat apmācīt modeli ar 1000 atkārtojumu

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.

6. solis) Novērtējiet modeli

Jūs definējat numpy aprēķinātāju, lai novērtētu modeli. Novērtēšanai izmantojat visu datu kopu

# 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}

Jūsu precizitāte ir 82 procenti. Nākamajā sadaļā mēģināsit pārspēt loģistikas klasifikatoru ar kodola klasifikatoru

7. solis. Konstruējiet kodola klasifikatoru

Kodola novērtētājs vismaz konstrukcijas ziņā neatšķiras no tradicionālā lineārā klasifikatora. Ideja ir izteiktā kodola spēka izmantošana ar lineāro klasifikatoru.

Lai apmācītu kodola klasifikatoru, jums ir nepieciešami divi iepriekš definēti novērtētāji, kas pieejami TensorFlow:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Pirmajā sadaļā jūs uzzinājāt, ka, izmantojot kodola funkciju, zemā dimensija jāpārveido par augstu. Precīzāk, jūs izmantosiet Random Fourier, kas ir Gausa funkcijas tuvinājums. Par laimi, Tensorflow bibliotēkā ir funkcija: RandomFourierFeatureMapper. Modeli var apmācīt, izmantojot novērtētāju KernelLinearClassifier.

Lai izveidotu modeli, rīkojieties šādi:

1. Iestatiet kodola funkciju lielizmēra
2. Iestatiet hiperparametru L2
3. Izveidojiet modeli
4. Apmāciet modeli
5. Novērtējiet modeli

A solis. Iestatiet kodola funkciju lielizmēra

Pašreizējā datu kopā ir 14 funkcijas, kuras jūs pārveidosiet par jaunu 5000 dimensiju vektora augsto dimensiju. Transformācijas sasniegšanai jūs izmantojat izlases Furjē funkcijas. Ja atceraties Gausa kodola formulu, ņemiet vērā, ka ir jādefinē standarta novirzes parametrs. Šis parametra vadības elements līdzības mēram tiek izmantots klasifikācijas laikā.

Visus parametrus RandomFourierFeatureMapper var noregulēt ar:

• ievades_dimuls = 14
• izejas_dimuls = 5000
• stddev = 4

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

Jums jākonstruē kodola kartētājs, izmantojot objekta kolonnas, kas izveidotas iepriekš: feat_column

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

B solis) Iestatiet hiperparametru L2

Lai novērstu pārmērīgu uzstādīšanu, jūs sodāt zaudējumu funkciju ar L2 regulatoru. Jūs iestatāt L2 hiperparametru uz 0,1 un mācīšanās ātrumu uz 5

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1) 

C solis. Izveidojiet modeli

Nākamais solis ir līdzīgs lineārajai klasifikācijai. Jūs izmantojat iebūvēto aprēķinātāju KernelLinearClassifier. Ņemiet vērā, ka pievienojat iepriekš definēto kodola kartētāju un maināt modeļa direktoriju.

### 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'}

D solis) Apmāciet modeli

Tagad, kad ir izveidots kodola klasifikators, jūs esat gatavs to apmācīt. Jūs izvēlaties atkārtot modeli 2000 reizes

### 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): []}}) 

E solis) Novērtējiet modeli

Visbeidzot, bet ne mazāk svarīgi, jūs novērtējat sava modeļa veiktspēju. Jums vajadzētu būt iespējai pārvarēt loģistisko regresiju.

# 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

Galīgā precizitāte ir 84%, tas ir 2% uzlabojums, salīdzinot ar loģistisko regresiju. Pastāv kompromiss starp precizitātes uzlabošanu un skaitļošanas izmaksām. Jums jādomā, vai uzlabojums par 2% ir atšķirīgā klasifikatora patērētā laika vērtībā, un vai tas pārliecinoši ietekmē jūsu biznesu.

Kopsavilkums

Kodols ir lielisks līdzeklis, lai nelineāros datus pārveidotu par (gandrīz) lineāriem. Šīs metodes trūkums ir skaitļošanas ziņā laikietilpīgs un dārgs.

Zemāk jūs varat atrast vissvarīgāko kodu, lai apmācītu kodola klasifikatoru

Iestatiet kodola funkciju lielizmēra

• ievades_dimuls = 14
• izejas_dimuls = 5000
• stddev = 4

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

Iestatiet hiperparametru L2

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1) 

Izveidojiet modeli

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train") 

Apmāciet modeli

estimator_kernel.fit(input_fn=train_input_fn, steps=2000) 

Novērtējiet modeli

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)