Kernel Gaussian în învățarea automată: exemple de metode de kernel

Scopul acestui tutorial este de a face un set de date separabil liniar. Tutorialul este împărțit în două părți:

1. Transformarea caracteristicilor
2. Antrenează un clasificator Kernel cu Tensorflow

În prima parte, veți înțelege ideea din spatele unei metode Kernel în Machine Learning, în timp ce în a doua parte, veți vedea cum să instruiți un clasificator de nucleu cu Tensorflow. Veți utiliza setul de date pentru adulți. Obiectivul acestui set de date este de a clasifica veniturile sub și peste 50k, cunoscând comportamentul fiecărei gospodării.

În acest tutorial veți învăța-

• De ce aveți nevoie de Metode Kernel?
• Ce este un kernel în învățarea automată?
• Tipuri de metode de nucleu
• Antrenează clasificatorul Kernel Gauss cu TensorFlow

De ce aveți nevoie de Metode Kernel?

Scopul fiecărui clasificator este de a prezice clasele corect. Pentru aceasta, setul de date ar trebui să fie separabil. Uită-te la complotul de mai jos; este destul de simplu să vezi că toate punctele de deasupra liniei negre aparțin clasei întâi și celelalte puncte clasei a doua. Cu toate acestea, este extrem de rar să ai un set de date atât de simplu. În majoritatea cazurilor, datele nu sunt separabile. Metodele kernelului în Învățarea automată le dau greu dificultăților clasificatorilor naivi, precum o regresie logistică.

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

În figura de mai jos, trasăm un set de date care nu este separabil liniar. Dacă tragem o linie dreaptă, majoritatea punctelor nu vor fi clasificate în clasa corectă.

O modalitate de a aborda această problemă este de a lua setul de date și de a transforma datele într-o altă hartă de caracteristici. Înseamnă că veți utiliza o funcție pentru a transforma datele într-un alt plan, care ar trebui să fie liniar.

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

Datele din figura de mai sus sunt într-un plan 2D Kernel Gaussian, care nu este separabil. Puteți încerca să transformați aceste date într-o tridimensiune, înseamnă că creați o figură cu 3 axe.

În exemplul nostru Kernel Gaussian, vom aplica o mapare polinomială pentru a aduce datele la o dimensiune 3D. Formula pentru transformarea datelor este următoarea.

Definiți o funcție în Gaussian Kernel Python pentru a crea noile hărți de caracteristici

Puteți utiliza numpy pentru a codifica formula de mai sus:

Formulă	Cod Numpy echivalent
X	x [:, 0] **
y	x [:, 1]
x 2	x [:, 0] ** 2
	np.sqrt (2) *
X y	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

Noua mapare ar trebui să aibă 3 dimensiuni cu 16 puncte

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Să facem un nou grafic cu 3 axe, x, y și respectiv 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() 

Vedem o îmbunătățire, dar dacă schimbăm orientarea complotului, este clar că setul de date este acum separabil

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

Pentru a manipula un set de date mare și poate fi necesar să creați mai mult de 2 dimensiuni, vă veți confrunta cu o mare problemă folosind metoda de mai sus. De fapt, trebuie să transformați toate punctele de date, ceea ce în mod clar nu este durabil. Vă va dura vârste, iar computerul dvs. poate rămâne fără memorie.

Cea mai obișnuită modalitate de a depăși această problemă este utilizarea unui nucleu .

Ce este un kernel în învățarea automată?

Ideea este de a utiliza un spațiu de dimensiuni mai mari pentru a face datele aproape liniar separabile, așa cum se arată în figura de mai sus.

Există o mulțime de spații cu dimensiuni superioare pentru a face punctele de date separate. De exemplu, am arătat că maparea polinomială este un început excelent.

De asemenea, am demonstrat că, cu o mulțime de date, aceste transformări nu sunt eficiente. În schimb, puteți utiliza o funcție Kernel în Machine Learning pentru a modifica datele fără a trece la un nou plan de caracteristici.

Magia nucleului este de a găsi o funcție care să evite toate problemele pe care le presupune calculul de înaltă dimensiune. Rezultatul unui nucleu este un scalar, sau spus diferit, ne întoarcem la spațiul unidimensional

După ce ați găsit această funcție, o puteți conecta la clasificatorul liniar standard.

Să vedem un exemplu pentru a înțelege conceptul de Kernel Machine Learning. Aveți doi vectori, x1 și x2. Obiectivul este de a crea o dimensiune superioară utilizând o mapare polinomială. Ieșirea este egală cu produsul punct al noii hărți de caracteristici. Din metoda de mai sus, trebuie să:

1. Transformă x1 și x2 într-o nouă dimensiune
2. Calculați produsul punct: comun tuturor nucleelor
3. Transformă x1 și x2 într-o nouă dimensiune

Puteți utiliza funcția creată mai sus pentru a calcula dimensiunea superioară.

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

Ieșire

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

Calculați produsul dot

Puteți utiliza obiectul punct din numpy pentru a calcula produsul punct între primul și al doilea vector stocat în x_1.

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

Ieșirea este 8100. Veți vedea problema, trebuie să stocați în memorie o nouă hartă de caracteristici pentru a calcula produsul dot. Dacă aveți un set de date cu milioane de înregistrări, este ineficient din punct de vedere al calculului.

În schimb, puteți utiliza nucleul polinomial pentru a calcula produsul punct fără a transforma vectorul. Această funcție calculează produsul punct al lui x1 și x2 ca și cum acești doi vectori ar fi fost transformați în dimensiunea superioară. Spus diferit, o funcție de nucleu calculează rezultatele produsului punct dintr-un alt spațiu de caracteristici.

Puteți scrie funcția nucleului polinomial în Python după cum urmează.

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

Este puterea produsului punct al a doi vectori. Mai jos, întoarceți al doilea grad al nucleului polinomial. Ieșirea este egală cu cealaltă metodă. Aceasta este magia nucleului.

polynomial_kernel(x1, x2, p=2)8100 

Tipuri de metode de nucleu

Există o mulțime de tehnici diferite de kernel disponibile. Cel mai simplu este nucleul liniar. Această funcție funcționează destul de bine pentru clasificarea textului. Celălalt nucleu este:

• Kernel polinomial
• Kernel Gaussian

În exemplul cu TensorFlow, vom folosi Fourier aleator. TensorFlow are un build in estimator pentru a calcula noul spațiu de caracteristici. Funcția de filtru Gauss este o aproximare a funcției kernelului Gauss.

Funcția de filtrare Gaussian calculează similaritatea dintre punctele de date într-un spațiu dimensional mult mai mare.

Antrenează clasificatorul Kernel Gauss cu TensorFlow

Obiectivul algoritmului este de a clasifica gospodăria care câștigă mai mult sau mai puțin de 50k.

Veți evalua o învățare logistică a regresiei automate a kernelului pentru a avea un model de referință. După aceea, veți antrena un clasificator Kernel pentru a vedea dacă puteți obține rezultate mai bune.

Utilizați următoarele variabile din setul de date pentru adulți:

• vârstă
• clasa de lucru
• fnlwgt
• educaţie
• număr_educare
• marital
• ocupaţie
• relaţie
• rasă
• sex
• câștig de capital
• pierderea_capitalului
• ore_saptamana
• tara de origine
• eticheta

Veți proceda după cum urmează înainte de a vă antrena și evalua modelul:

• Pasul 1) Importați bibliotecile
• Pasul 2) Importați datele
• Pasul 3) Pregătiți datele
• Pasul 4) Construiți input_fn
• Pasul 5) Construiți modelul logistic: modelul de bază
• Pasul 6) Evaluează modelul
• Pasul 7) Construiți clasificatorul Kernel
• Pasul 8) Evaluați clasificatorul Kernel

Pasul 1) Importați bibliotecile

Pentru a importa și instrui modele de kernel în inteligență artificială, trebuie să importați tensorflow, panda și numpy

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

Pasul 2) Importați datele

Descărcați datele de pe următorul site web și le importați ca cadru de date 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) 

Acum că trenul și setul de testare sunt definite, puteți schimba eticheta coloanei din șir în întreg. tensorflow nu acceptă valoarea șirului pentru etichetă.

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)

Pasul 3) Pregătiți datele

Setul de date conține atât caracteristici continue, cât și caracteristice. O bună practică este standardizarea valorilor variabilelor continue. Puteți utiliza funcția StandardScaler din sci-kit learn. Creați și o funcție definită de utilizator pentru a face mai ușoară conversia trenului și a setului de testare. Rețineți că, concatenați variabilele continue și categorice la un set de date comun, iar matricea trebuie să fie de tipul: 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 

Funcția transformator este gata, puteți converti setul de date și puteți crea funcția 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 pasul următor, veți instrui o regresie logistică. Vă va oferi o precizie de bază. Obiectivul este de a bate linia de bază cu un alt algoritm, și anume un clasificator Kernel.

Pasul 4) Construiți modelul logistic: modelul de bază

Construiți coloana caracteristică cu obiectul real_valued_column. Se va asigura că toate variabilele sunt date numerice dense.

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

Estimatorul este definit utilizând TensorFlow Estimator, instruiți coloanele caracteristicilor și unde să salvați graficul.

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} 

Veți instrui regresia logisitc folosind mini-loturi de dimensiunea 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) 

Puteți instrui modelul cu 1.000 de iterații

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.

Pasul 6) Evaluează modelul

Definiți estimatorul numpy pentru a evalua modelul. Utilizați întregul set de date pentru evaluare

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

Aveți o precizie de 82 de procente. În secțiunea următoare, veți încerca să bateți clasificatorul logistic cu un clasificator Kernel

Pasul 7) Construiți clasificatorul Kernel

Estimatorul nucleului nu este atât de diferit de clasificatorul liniar tradițional, cel puțin în termeni de construcție. Ideea din spatele este de a utiliza puterea nucleului explicit cu clasificatorul liniar.

Aveți nevoie de doi estimatori predefiniți disponibili în TensorFlow pentru a instrui Kernel Classifier:

• RandomFourierFeatureMapper
• KernelLinearClassifier

În prima secțiune ați aflat că trebuie să transformați dimensiunea joasă într-o dimensiune înaltă utilizând o funcție de nucleu. Mai precis, veți utiliza Fourier aleatoriu, care este o aproximare a funcției Gaussiene. Din fericire, Tensorflow are funcția din biblioteca sa: RandomFourierFeatureMapper. Modelul poate fi instruit folosind estimatorul KernelLinearClassifier.

Pentru a construi modelul, veți urma acești pași:

1. Setați funcția Kernel de dimensiuni mari
2. Setați hiperparametrul L2
3. Construiește modelul
4. Antrenează modelul
5. Evaluează modelul

Pasul A) Setați funcția Kernel de dimensiuni mari

Setul de date curent conține 14 caracteristici pe care le veți transforma într-o nouă dimensiune înaltă a vectorului cu 5.000 de dimensiuni. Folosiți caracteristicile Fourier aleatorii pentru a realiza transformarea. Dacă vă amintiți formula Kernel Gaussian, observați că există parametrul de deviere standard de definit. Acest parametru controlează măsura de similaritate utilizată în timpul clasificării.

Puteți regla toți parametrii în RandomFourierFeatureMapper cu:

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

Trebuie să construiți maperul kernel utilizând coloanele de caracteristici create înainte: feat_column

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

Pasul B) Setați hiperparametrul L2

Pentru a preveni suprasolicitarea, penalizați funcția de pierdere cu regulatorul L2. Setați hiperparametrul L2 la 0,1 și rata de învățare la 5

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

Pasul C) Construiți modelul

Următorul pas este similar cu clasificarea liniară. Folosiți estimatorul de încorporare KernelLinearClassifier. Rețineți că adăugați maperul kernel definit anterior și schimbați directorul modelului.

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

Pasul D) Antrenează modelul

Acum că clasificatorul Kernel este construit, sunteți gata să îl instruiți. Alegeți să iterați de 2000 de ori modelul

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

Pasul E) Evaluează modelul

Nu în ultimul rând, evaluați performanța modelului dvs. Ar trebui să puteți învinge regresia logistică.

# 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

Precizia finală este de 84%, este o îmbunătățire de 2% comparativ cu regresia logistică. Există un compromis între îmbunătățirea preciziei și costul de calcul. Trebuie să vă gândiți dacă o îmbunătățire de 2% merită timpul consumat de diferitul clasificator și dacă are un impact convingător asupra afacerii dvs.

rezumat

Un nucleu este un instrument excelent pentru a transforma datele neliniare în (aproape) liniare. Deficiența acestei metode este consumatoare de timp și costisitoare.

Mai jos, puteți găsi cel mai important cod pentru a instrui un nucleu clasificator

Setați funcția Kernel de dimensiuni mari

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

Setați hiperparametrul L2

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

Construiește modelul

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

Antrenează modelul

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

Evaluează modelul

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