Gaussovo jedro v strojnem učenju: primeri jedrnih metod

Namen te vaje je narediti nabor podatkov linearno ločljiv. Vadnica je razdeljena na dva dela:

1. Preoblikovanje lastnosti
2. Izobražite klasifikator jedra s sistemom Tensorflow

V prvem delu boste razumeli zamisel o metodi jedra v strojnem učenju, v drugem delu pa boste videli, kako trenirati klasifikator jedr s Tensorflow Uporabili boste nabor podatkov za odrasle. Cilj tega nabora podatkov je razvrstiti dohodek pod in nad 50 000, ob poznavanju vedenja vsakega gospodinjstva.

V tej vadnici boste izvedeli-

• Zakaj potrebujete metode jedra?
• Kaj je jedro v strojnem učenju?
• Vrste jedrnih metod
• Izobrazite klasifikator Gaussovega jedra s sistemom TensorFlow

Zakaj potrebujete metode jedra?

Namen vsakega klasifikatorja je pravilno predvideti razrede. Za to mora biti nabor podatkov ločljiv. Oglejte si spodnjo ploskev; dokaj enostavno je videti, da vse točke nad črno črto spadajo v prvi razred, druge točke pa v drugi razred. Vendar je izjemno redko, da je nabor podatkov tako preprost. V večini primerov podatkov ni mogoče ločiti. Metode jedra v strojnem učenju težko naivne klasifikatorje, kot je logistična regresija.

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 spodnji sliki načrtujemo nabor podatkov, ki ni linearno ločljiv. Če narišemo ravno črto, večina točk ne bo razvrščena v pravi razred.

Eden od načinov za reševanje te težave je, da vzamemo nabor podatkov in podatke pretvorimo v drug zemljevid lastnosti. To pomeni, da boste uporabili funkcijo za pretvorbo podatkov v drug načrt, ki bi ga bilo treba povezati.

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

Podatki s zgornje slike so v 2D načrtu Gaussovega jedra, ki ga ni mogoče ločiti. Te podatke lahko poskusite pretvoriti v tridimenzionalno, kar pomeni, da ustvarite sliko s tremi osmi.

V našem primeru Gaussovega jedra bomo uporabili preslikavo polinoma, da bomo svoje podatke pripeljali v 3D dimenzijo. Formula za pretvorbo podatkov je naslednja.

V Gaussovem jedru Python definirate funkcijo za ustvarjanje novih zemljevidov funkcij

Z numpy lahko kodirate zgornjo formulo:

Formula	Enakovredna Numpyjeva koda
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

Novo preslikavo naj bo v treh dimenzijah s 16 točkami

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Naredimo novo ploskev s 3 osmi, x, y in 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() 

Vidimo izboljšanje, vendar če spremenimo usmeritev ploskve, je jasno, da je nabor podatkov zdaj mogoče ločiti

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

Če želite manipulirati z velikim naborom podatkov in boste morda morali ustvariti več kot 2 dimenziji, se boste z zgornjo metodo soočili z velikim problemom. Pravzaprav morate spremeniti vse podatkovne točke, kar očitno ni trajnostno. Vzela vam bo starost in v računalniku bo morda zmanjkalo pomnilnika.

Najpogostejši način za premagovanje te težave je uporaba jedra .

Kaj je jedro v strojnem učenju?

Ideja je uporabiti prostor z več dimenzijami, da bodo podatki skoraj linearno ločljivi, kot je prikazano na zgornji sliki.

Obstaja veliko prostorov višjih dimenzij, da lahko podatkovne točke ločimo. Na primer, pokazali smo, da je preslikava polinov odličen začetek.

Dokazali smo tudi, da z veliko podatki ta preobrazba ni učinkovita. Namesto tega lahko s funkcijo jedra v strojnem učenju spremenite podatke, ne da bi prešli na nov načrt funkcij.

Čarobnost jedra je, da poišče funkcijo, ki se izogne ​​vsem težavam, ki jih pomeni visokorazsežno računanje. Rezultat jedra je skalar, ali drugače rečeno, vrnili smo se v enodimenzionalni prostor

Ko najdete to funkcijo, jo lahko priključite na standardni linearni klasifikator.

Poglejmo primer za razumevanje koncepta Kernel Machine Learning. Imate dva vektorja, x1 in x2. Cilj je ustvariti višjo dimenzijo z uporabo polinomskega preslikavanja. Izhod je enak pikčastemu produktu novega zemljevida funkcij. Iz zgornje metode morate:

1. Pretvorite x1 in x2 v novo dimenzijo
2. Izračunajte pikčasti izdelek: skupen vsem jedrom
3. Pretvorite x1 in x2 v novo dimenzijo

Za izračun višje dimenzije lahko uporabite zgoraj ustvarjeno funkcijo.

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

Izhod

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

Izračunajte pikčasti izdelek

Za izračun pikastega izdelka med prvim in drugim vektorjem, shranjenim v x_1, lahko uporabite objektno piko iz numpy.

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

Izhod je 8100. Če vidite težavo, morate v pomnilnik shraniti nov zemljevid funkcij za izračun pikčastega izdelka. Če imate nabor podatkov z milijoni zapisov, je to računsko neučinkovito.

Namesto tega lahko uporabite polinomsko jedro za izračun pikčastega izdelka brez pretvorbe vektorja. Ta funkcija izračuna pikčasti zmnožek x1 in x2, kot da bi bila ta dva vektorja spremenjena v višjo dimenzijo. Drugače rečeno, funkcija jedra izračuna rezultate pikčastega izdelka iz drugega prostora funkcij.

Funkcijo polinomskega jedra v Python lahko zapišete na naslednji način.

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

To je moč pikčastega izdelka dveh vektorjev. Spodaj vrnete drugo stopnjo polinomskega jedra. Rezultat je enak drugi metodi. To je čarobnost jedra.

polynomial_kernel(x1, x2, p=2)8100 

Vrste jedrnih metod

Na voljo je veliko različnih tehnik jedra. Najenostavnejše je linearno jedro. Ta funkcija deluje zelo dobro pri razvrščanju besedil. Drugo jedro je:

• Polinomsko jedro
• Gaussovo jedro

V primeru s TensorFlow bomo uporabili naključni Fourier. TensorFlow ima vgrajeni ocenjevalec za izračun novega prostora funkcij. Funkcija Gaussovega filtra je približek funkcije Gaussovega jedra.

Gaussova funkcija filtriranja izračuna podobnost med podatkovnimi točkami v veliko višjem dimenzijskem prostoru.

Izobrazite klasifikator Gaussovega jedra s sistemom TensorFlow

Cilj algoritma je razvrstiti gospodinjstvo, ki zasluži več ali manj kot 50 tisoč.

Ocenili boste logistično jedrsko regresijsko strojno učenje, da boste imeli primerjalni model. Po tem boste usposobili klasifikator jedra, da vidite, ali lahko dosežete boljše rezultate.

Iz nabora podatkov za odrasle uporabljate naslednje spremenljivke:

• starost
• delovni razred
• fnlwgt
• izobraževanje
• izobraževalna_številka
• zakonski
• poklic
• razmerje
• dirka
• seks
• kapitalski dobiček
• izguba kapitala
• ur_teden
• Domača država
• nalepko

Pred treningom in ocenjevanjem modela boste nadaljevali, kot sledi:

• 1. korak) Uvozite knjižnice
• 2. korak) Uvozite podatke
• Korak 3) Pripravite podatke
• Korak 4) Sestavite input_fn
• 5. korak) Izdelajte logistični model: osnovni model
• Korak 6) Ocenite model
• Korak 7) Izdelajte klasifikator jedra
• Korak 8) Ocenite klasifikator jedra

1. korak) Uvozite knjižnice

Če želite uvoziti in usposobiti modele jedra v umetni inteligenci, morate uvoziti tensorflow, pande in numpy

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

2. korak) Uvozite podatke

Podatke prenesete z naslednjega spletnega mesta in jih uvozite kot podatkovni okvir panda.

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

Zdaj, ko sta vlak in testni niz definirana, lahko spremenite oznako stolpca iz niza v celo število. tensorflow ne sprejme vrednosti niza za nalepko.

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)

Korak 3) Pripravite podatke

Nabor podatkov vsebuje tako neprekinjene kot kategorične funkcije. Dobra praksa je standardizacija vrednosti zveznih spremenljivk. Uporabite lahko funkcijo StandardScaler iz sci-kit learn. Ustvarite tudi uporabniško določeno funkcijo, da olajšate pretvorbo vlaka in testnega kompleta. Upoštevajte, da neprekinjene in kategorične spremenljivke povežete s skupnim naborom podatkov, polje pa naj bo tipa: 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 

Funkcija transformatorja je pripravljena, pretvorite lahko nabor podatkov in ustvarite funkcijo 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) 

V naslednjem koraku boste trenirali logistično regresijo. Dala vam bo izhodiščno natančnost. Cilj je premagati izhodišče z drugačnim algoritmom, in sicer klasifikatorjem jedra.

Korak 4) Izdelajte logistični model: osnovni model

Stolpec lastnosti sestavite s predmetom real_valued_column. Poskrbel bo, da bodo vse spremenljivke gosti numerični podatki.

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

Ocenjevalnik je definiran s pomočjo ocenjevalnika TensorFlow, naročite stolpce funkcij in kam shraniti graf.

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} 

Logisitc regresijo boste trenirali z uporabo mini serij velikosti 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) 

Model lahko trenirate s 1.000 ponovitvami

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.

Korak 6) Ocenite model

Za oceno modela določite ocenjevalnik numpy. Za oceno uporabite celoten nabor podatkov

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

Imate natančnost 82 odstotkov. V naslednjem razdelku boste poskusili logistični klasifikator premagati s klasifikatorjem jedra

Korak 7) Izdelajte klasifikator jedra

Ocenjevalec jedra se vsaj v smislu izdelave ne razlikuje tako od tradicionalnega linearnega klasifikatorja. Zamisel je uporabiti moč eksplicitnega jedra z linearnim klasifikatorjem.

Za usposabljanje klasifikatorja jeder potrebujete dva vnaprej določena ocenjevalnika, ki sta na voljo v programu TensorFlow:

• RandomFourierFeatureMapper
• KernelLinearClassifier

V prvem odseku ste izvedeli, da morate z uporabo funkcije jedra pretvoriti nizko dimenzijo v visoko dimenzijo. Natančneje, uporabili boste naključni Fourier, ki je približek Gaussove funkcije. Na srečo ima Tensorflow v svoji knjižnici funkcijo: RandomFourierFeatureMapper. Model je mogoče usposobiti s pomočjo ocenjevalnika KernelLinearClassifier.

Če želite zgraditi model, sledite tem korakom:

1. Nastavite funkcijo jedra visoke dimenzije
2. Nastavite hiperparameter L2
3. Zgradite model
4. Trenirajte model
5. Ocenite model

Korak A) Nastavite funkcijo jedra visoke dimenzije

Trenutni nabor podatkov vsebuje 14 funkcij, ki jih boste spremenili v novo visoko dimenzijo 5.000-dimenzionalnega vektorja. Za preobrazbo uporabljate naključne Fourierjeve funkcije. Če se spomnite formule Gaussovega jedra, opazite, da je treba določiti parameter standardnega odklona. Ta parameter nadzoruje merilo podobnosti, ki se uporablja med razvrščanjem.

Vse parametre lahko nastavite v RandomFourierFeatureMapper z:

• 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') 

Preslikavo jedra morate izdelati z uporabo stolpcev funkcij, ustvarjenih pred: feat_column

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

Korak B) Nastavite hiperparameter L2

Da preprečite prekomerno opremljanje, funkcijo izgube kaznite z regulatorjem L2. Hiperparameter L2 nastavite na 0,1, stopnjo učenja pa na 5

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

Korak C) Zgradite model

Naslednji korak je podoben linearni klasifikaciji. Uporabljate vgrajeni ocenjevalnik KernelLinearClassifier. Upoštevajte, da dodate predhodno definirano preslikavo jedra in spremenite imenik modela.

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

Korak D) Izurite model

Zdaj, ko je klasifikator jedra zgrajen, ste ga pripravljeni trenirati. Odločite se za 2000-kratno ponovitev modela

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

Korak E) Ocenite model

Nenazadnje ocenjujete uspešnost svojega modela. Morali bi biti sposobni premagati logistično regresijo.

# 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

Končna natančnost je 84%, to je 2% izboljšanje v primerjavi z logistično regresijo. Obstaja kompromis med izboljšanjem natančnosti in računskimi stroški. Razmisliti morate, ali je 2-odstotno izboljšanje vredno časa, ki ga porabi različni klasifikator, in ali ima prepričljiv vpliv na vaše podjetje.

Povzetek

Jedro je odlično orodje za pretvorbo nelinearnih podatkov v (skoraj) linearne. Pomanjkljivost te metode je računsko dolgotrajna in draga.

Spodaj najdete najpomembnejšo kodo za usposabljanje klasifikatorja jedra

Nastavite funkcijo jedra visoke dimenzije

• 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') 

Nastavite hiperparameter L2

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

Zgradite model

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

Trenirajte model

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

Ocenite model

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