Kernel gaussian în învățare automată: Python Metode Kernel
Evelyn Clarke
Scopul acestui tutorial este de a face un set de date separabil liniar. Tutorialul este împărțit în două părți:
- Transformarea caracteristicilor
- 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ă antrenați un clasificator de kernel cu Tensorflow. Veți folosi 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.
De ce aveți nevoie de Metode Kernel?
Scopul fiecărui clasificator este de a prezice corect clasele. 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 primei clase, iar celelalte puncte din clasa a doua. Cu toate acestea, este extrem de rar să existe un set de date atât de simplu. În majoritatea cazurilor, datele nu sunt separabile. Metodele kernel din Machine Learning le dă greutății clasificatorilor naivi, precum o regresie logistică.
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
x_lin = np.array([1,2,3,4,5,6,7,8,9,10]) y_lin = np.array([2,2,3,2,2,9,6,8,8,9]) label_lin = np.array([0,0,0,0,0,1,1,1,1,1]) fig = plt.figure() ax=fig.add_subplot(111) plt.scatter(x_lin, y_lin, c=label_lin, s=60) plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2) ax.set_xlim([-5,15]) ax.set_ylim([-5,15])plt.show()
În figura de mai jos, reprezentă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 rezolva această problemă este să luați setul de date și să transformați datele într-o altă hartă a caracteristicilor. Înseamnă că veți folosi 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 Gaussian Kernel care nu este separabil. Puteți încerca să transformați aceste date într-o dimensiune tridimensională, înseamnă că creați o figură cu 3 axe.
În exemplul nostru Gaussian Kernel, vom aplica o mapare polinomială pentru a aduce datele noastre la o dimensiune 3D. Formula de transformare a datelor este următoarea.
Definiți o funcție în Kernel Gaussian Python pentru a crea noile hărți de caracteristici
Poți să folosești NumPy pentru a codifica formula de mai sus:
| Formulă | Cod Numpy echivalent |
|---|---|
| x | x[:,0]** |
| y | x[:,1] |
| x2 | x[:,0]***2 |
 |
np.sqrt(2)* |
| xy | x[:,0]*x[:,1] |
| y2 | x[:,1]***2 |
### illustration purpose
def mapping(x, y):
x = np.c_[(x, y)]
if len(x) > 2:
x_1 = x[:,0]**2
x_2 = np.sqrt(2)*x[:,0]*x[:,1]
x_3 = x[:,1]**2
else:
x_1 = x[0]**2
x_2 = np.sqrt(2)*x[0]*x[1]
x_3 = x[1]**2
trans_x = np.array([x_1, x_2, x_3])
return trans_x
Noua mapare ar trebui să fie cu 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.
# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')
plt.show()
Vedem o îmbunătățire, dar dacă schimbăm orientarea diagramei, este clar că setul de date este acum separabil
# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60)
ax.view_init(0, -180)ax.set_ylim([150,-50])
ax.set_zlim([-10000,10000])
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')plt.show()
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 sustenabil. Îți va lua o mulțime de ani, iar computerul poate rămâne fără memorie.
Cea mai comună modalitate de a depăși această problemă este utilizarea a nucleu.
Ce este un kernel în învățarea automată?
Ideea este de a folosi un spațiu de caracteristici de dimensiune mai mare pentru a face datele aproape liniar separabile, așa cum se arată în figura de mai sus.
Există o mulțime de spații dimensionale mai mari pentru a face punctele de date separabile. De exemplu, am arătat că maparea polinomială este un început excelent.
De asemenea, am demonstrat că, cu multe 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 funcții.
Magia nucleului este să găsești o funcție care să evite toate problemele implicate de calculul de dimensiuni mari. Rezultatul unui nucleu este un scalar, sau spus altfel, 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 mai mare prin utilizarea unei cartografii polinomiale. Rezultatul este egal cu produsul punctual al noii hărți de caracteristici. Din metoda de mai sus, trebuie să:
- Transformă x1 și x2 într-o nouă dimensiune
- Calculați produsul punctual: comun tuturor nucleelor
- Transformă x1 și x2 într-o nouă dimensiune
Puteți utiliza funcția creată mai sus pentru a calcula dimensiunea superioară.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
producție
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Calculați produsul punctual
Puteți utiliza punctul obiect din numpy pentru a calcula produsul scalar dintre primul și al doilea vector stocat în x_1.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Ieșirea este 8100. Vedeți problema, trebuie să stocați în memorie o nouă hartă a caracteristicilor pentru a calcula produsul punctual. Dacă aveți un set de date cu milioane de înregistrări, este ineficient din punct de vedere computațional.
În schimb, puteți utiliza nucleu polinom pentru a calcula produsul scalar fără a transforma vectorul. Această funcție calculează produsul scalar al lui x1 și x2 ca și cum acești doi vectori ar fi fost transformați în dimensiunea superioară. Spus altfel, o funcție de nucleu calculează rezultatele produsului punctual dintr-un alt spațiu de caracteristici.
Puteți scrie funcția kernel polinomială în Python după cum urmează.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Este puterea produsului scalar a doi vectori. Mai jos, returnați gradul doi al nucleului polinom. Ieșirea este egală cu cealaltă metodă. Aceasta este magia nucleului.
polynomial_kernel(x1, x2, p=2) 8100
Tipuri de Metode Kernel
Există o mulțime de tehnici Kernel disponibile. Cel mai simplu este nucleul liniar. Această funcție funcționează destul de bine pentru clasificarea textului. Celălalt nucleu este:
- Nucleu polinom
- Kernel gaussian
În exemplul cu TensorFlow, vom folosi Fourier aleatoriu. TensorFlow are un estimator integrat pentru a calcula noul spațiu de caracteristici. Funcția de filtru gaussian este o aproximare a funcției nucleului gaussian.
Funcția de filtrare gaussiană calculează similitudinea dintre punctele de date dintr-un spațiu dimensional mult mai mare.
Antrenează clasificatorul Gaussian Kernel 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 automată a regresiei kernelului logistic 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
- educație_num
- marital
- ocupație
- relaţie
- rasă
- sex
- câștig de capital
- pierdere_capital
- ore_săptămână
- tara de origine
- etichetă
Veți proceda după cum urmează înainte de a vă instrui și de a 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) Evaluați modelul
- Pasul 7) Construiți clasificatorul Kernel
- Pasul 8) Evaluați clasificatorul Kernel
Pas 1) Importă bibliotecile
Pentru a importa și antrena modele Kernel în Inteligența artificială , trebuie să importați tensorflow, panda și numpy
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Pas 2) Importă datele
Descărcați datele din următoarele și îl importați ca un cadru de date panda.
## Define path data COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label'] PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data" PATH_test ="https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test "## Import df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False) df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)
Acum că trenul și setul de testare sunt definite, puteți schimba eticheta coloanei din șir în număr î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)
Pas 3) Pregătiți datele
Setul de date conține atât caracteristici continue, cât și categoriale. O bună practică este standardizarea valorilor variabilelor continue. Puteți folosi funcția StandardScaler de la sci-kit learn. De asemenea, creați o funcție definită de utilizator pentru a facilita convertirea trenului și a setului de testare. Rețineți că, concatenați variabilele continue și categoriale la un set de date comun și matricea ar trebui 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 StandardScaler
from sklearn import preprocessing
def prep_data_str(df):
scaler = StandardScaler()
le = preprocessing.LabelEncoder()
df_toscale = df[COLUMNS_INT]
df_scaled = scaler.fit_transform(df_toscale.astype(np.float64))
X_1 = df[CATE_FEATURES].apply(le.fit_transform)
y = df['label'].astype(np.int32)
X_conc = np.c_[df_scaled, X_1].astype(np.float32)
return X_conc, y
Funcția de 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 antrena o regresie logistică. Vă va oferi o precizie de referință. Obiectivul este de a depăși linia de bază cu un alt algoritm, și anume un clasificator Kernel.
Pas 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 folosind TensorFlow Estimator, tu instruiești coloanele de caracteristici și unde să salvezi 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a2003f780>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Veți antrena regresia logistică folosind mini-loturi de dimensiunea 200.
# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"features": X_train},
y=y_train,
batch_size=200,
num_epochs=None,
shuffle=True)
Puteți antrena 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 = 1 INFO:tensorflow:global_step/sec: 324.16 INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec) INFO:tensorflow:global_step/sec: 267.092 INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec) INFO:tensorflow:global_step/sec: 292.679 INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec) INFO:tensorflow:global_step/sec: 225.582 INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec) INFO:tensorflow:global_step/sec: 209.975 INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec) INFO:tensorflow:global_step/sec: 241.648 INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec) INFO:tensorflow:global_step/sec: 305.193 INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec) INFO:tensorflow:global_step/sec: 396.295 INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec) INFO:tensorflow:global_step/sec: 359.857 INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec) INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt. INFO:tensorflow:Loss for final step: 67.79706. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>
Pas 6) Evaluați modelul
Definiți estimatorul numpy pentru a evalua modelul. Utilizați întregul set de date pentru evaluare
# Evaluation
test_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"features": X_test},
y=y_test,
batch_size=16281,
num_epochs=1,
shuffle=False)
estimator.evaluate(input_fn=test_input_fn, steps=1)
INFO:tensorflow:Calling model_fn. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23 INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663,
'accuracy_baseline': 0.76377374,
'auc': 0.84898686,
'auc_precision_recall': 0.67214864,
'average_loss': 0.3877216,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 6312.495,
'precision': 0.7362797,
'prediction/mean': 0.21208474,
'recall': 0.39417577}
Ai o precizie de 82 de procente. În secțiunea următoare, veți încerca să învingeți clasificatorul logistic cu un clasificator Kernel
Pas 7) Construiți clasificatorul Kernel
Estimatorul nucleului nu este atât de diferit de clasificatorul liniar tradițional, cel puțin din punct de vedere al construcției. Ideea din spate este de a folosi puterea nucleului explicit cu clasificatorul liniar.
Aveți nevoie de doi estimatori predefiniti disponibili în TensorFlow pentru a antrena Kernel Clasifier:
- RandomFourierFeatureMapper
- KernelLinearClassifier
Ați învățat în prima secțiune că trebuie să transformați dimensiunea joasă într-o dimensiune înaltă folosind o funcție de nucleu. Mai precis, veți folosi Fourier aleatoriu, care este o aproximare a funcției gaussiene. Din fericire, Tensorflow are funcția în biblioteca sa: RandomFourierFeatureMapper. Modelul poate fi antrenat folosind estimatorul KernelLinearClassifier.
Pentru a construi modelul, veți urma acești pași:
- Setați funcția Kernel de dimensiune mare
- Setați hiperparametrul L2
- Construiți modelul
- Antrenează modelul
- Evaluați modelul
Pasul A) Setați funcția Kernel de dimensiune mare
Setul de date actual conține 14 caracteristici pe care le veți transforma într-o nouă dimensiune mare a vectorului cu 5.000 de dimensiuni. Utilizați caracteristicile aleatorii Fourier pentru a realiza transformarea. Dacă vă amintiți formula Gaussian Kernel, observați că există un parametru de abatere standard de definit. Acest parametru controlează măsura de similitudine utilizată în timpul clasificării.
Puteți regla toți parametrii în RandomFourierFeatureMapper cu:
- input_dim = 14
- output_dim= 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Trebuie să construiți mapatorul nucleului utilizând coloanele de caracteristici create înainte: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Pasul B) Setați hiperparametrul L2
Pentru a preveni supraajustarea, 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ă. Utilizați estimatorul încorporat KernelLinearClassifier. Rețineți că adăugați mapperul kernel definit anterior și modificați directorul modelului.
### Prep estimator
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(
n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.
Instructions for updating:
Please switch to tf.contrib.estimator.*_head.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.
Instructions for updating:
Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options {
per_process_gpu_memory_fraction: 1.0
}
, '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}
Pasul D) Antrenează modelul
Acum că clasificatorul Kernel este construit, sunteți gata să-l antrenați. Alegeți să repetați de 2000 de ori modelul
### estimate estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into kernel_train/model.ckpt.
INFO:tensorflow:loss = 0.6931474, step = 1
INFO:tensorflow:global_step/sec: 86.6365
INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)
INFO:tensorflow:global_step/sec: 80.1986
INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)
INFO:tensorflow:global_step/sec: 79.6376
INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)
INFO:tensorflow:global_step/sec: 95.8442
INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)
INFO:tensorflow:global_step/sec: 93.7799
INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)
INFO:tensorflow:global_step/sec: 94.7071
INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)
INFO:tensorflow:global_step/sec: 90.7402
INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)
INFO:tensorflow:global_step/sec: 94.4924
INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)
INFO:tensorflow:global_step/sec: 95.3472
INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)
INFO:tensorflow:global_step/sec: 97.2928
INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)
INFO:tensorflow:global_step/sec: 85.6761
INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)
INFO:tensorflow:global_step/sec: 91.4194
INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)
INFO:tensorflow:global_step/sec: 82.5954
INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)
INFO:tensorflow:global_step/sec: 89.8748
INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)
INFO:tensorflow:global_step/sec: 76.9761
INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)
INFO:tensorflow:global_step/sec: 73.7192
INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)
INFO:tensorflow:global_step/sec: 83.0573
INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)
INFO:tensorflow:global_step/sec: 71.7029
INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)
INFO:tensorflow:global_step/sec: 73.2663
INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec)
INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt.
INFO:tensorflow:Loss for final step: 0.37795097.
KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})
Pasul E) Evaluați modelul
Nu în ultimul rând, evaluezi performanța modelului tău. Ar trebui să poți învinge regresia logistică.
# Evaluate and report metrics. eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:50 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51 INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004
Precizia finală este de 84%, este o îmbunătățire de 2% față de regresia logistică. Există un compromis între îmbunătățirea preciziei și costul de calcul. Trebuie să vă gândiți dacă îmbunătățirea de 2% merită timpul consumat de diferitele clasificatoare și dacă are un impact convingător asupra afacerii dvs.
Rezumat
Un nucleu este un instrument excelent pentru a transforma date neliniare în (aproape) liniare. Dezavantajul acestei metode este că este consumatoare de timp și costisitoare din punct de vedere al calculului.
Mai jos, puteți găsi cel mai important cod pentru a antrena un clasificator de nucleu
Setați funcția Kernel de dimensiune mare
- 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)
Construiți 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)
Evaluați modelul
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
