Gaussi kernel masinõppes: Python Kerneli meetodid
Evelyn Clarke
Selle õpetuse eesmärk on muuta andmestik lineaarselt eraldatavaks. Õpetus on jagatud kaheks osaks:
- Funktsiooni teisendus
- Treenige Kerneli klassifikaatorit Tensorflow abil
Esimeses osas saate aru masinõppe tuumameetodi ideest, teises osas aga, kuidas treenida Tensorflow abil kerneli klassifikaatorit. Kasutate täiskasvanutele mõeldud andmestikku. Selle andmestiku eesmärk on klassifitseerida tulud alla ja üle 50 XNUMX, teades iga leibkonna käitumist.
Miks on vaja Kerneli meetodeid?
Iga klassifikaatori eesmärk on klasse õigesti ennustada. Selleks peaks andmestik olema eraldatav. Vaadake allpool olevat süžeed; on üsna lihtne näha, et kõik musta joone kohal olevad punktid kuuluvad esimesse klassi ja teised punktid teise klassi. Nii lihtsa andmestiku olemasolu on aga äärmiselt haruldane. Enamasti ei ole andmed eraldatavad. Masinõppe tuumameetodid muudavad naiivsete klassifikaatorite, näiteks logistilise regressiooni, keeruliseks.
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()
Alloleval joonisel kujutame andmestikku, mis ei ole lineaarselt eraldatav. Kui tõmbame sirge, siis enamik punkte ei liigitata õigesse klassi.
Üks viis selle probleemi lahendamiseks on võtta andmestik ja teisendada andmed mõnele muule funktsioonikaardile. See tähendab, et kasutate funktsiooni andmete teisendamiseks teise plaani, mis peaks olema lineaarne.
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()
Ülaltoodud joonisel olevad andmed on 2D Gaussi tuumaplaanis, mida ei saa eraldada. Võite proovida neid andmeid kolmemõõtmeliseks teisendada, see tähendab, et loote 3 teljega joonise.
Gaussi tuuma näites rakendame oma andmete 3D-mõõtme viimiseks polünoomilist kaardistamist. Andmete teisendamise valem on järgmine.
Funktsiooni määrate Gaussi tuumas Python uute objektikaartide loomiseks
Võite kasutada tuim ülaltoodud valemi kodeerimiseks:
| Valem | Samaväärne Numpy kood |
|---|---|
| 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
Uus kaardistus peaks olema kolmemõõtmeline ja 3 punktiga
x_1 = mapping(x, y) x_1.shape
(3, 16)
Teeme uue graafiku 3 teljega, vastavalt x, y ja 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()
Näeme paranemist, kuid kui muudame graafiku orientatsiooni, on selge, et andmestik on nüüd eraldatav
# 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()
Suure andmestikuga manipuleerimiseks ja võib-olla peate looma rohkem kui 2 dimensiooni, seisate ülaltoodud meetodi kasutamisel silmitsi suure probleemiga. Tegelikult peate muutma kõik andmepunktid, mis pole ilmselgelt jätkusuutlik. See võtab teid kaua aega ja teie arvuti mälu võib tühjaks saada.
Kõige tavalisem viis selle probleemi lahendamiseks on kasutada a tuum.
Mis on masinõppes tuum?
Idee on kasutada suurema mõõtmega funktsiooniruumi, et muuta andmed peaaegu lineaarselt eraldatavaks, nagu on näidatud ülaltoodud joonisel.
Andmepunktide eraldamiseks on palju kõrgema mõõtmega ruume. Näiteks oleme näidanud, et polünoomide kaardistamine on suurepärane algus.
Samuti oleme näidanud, et suure hulga andmete korral ei ole need teisendused tõhusad. Selle asemel saate masinõppes kasutada kerneli funktsiooni, et muuta andmeid ilma uut funktsiooniplaani muutmata.
Kerneli võlu seisneb funktsiooni leidmises, mis väldib kõiki kõrgmõõtmelise arvutusega kaasnevaid probleeme. Kerneli tulemus on skalaar või teisiti öeldes oleme tagasi ühemõõtmelises ruumis
Kui olete selle funktsiooni leidnud, saate selle ühendada standardse lineaarse klassifikaatoriga.
Vaatame näidet, et mõista Kerneli masinõppe kontseptsiooni. Teil on kaks vektorit, x1 ja x2. Eesmärk on polünoomilise kaardistamise abil luua kõrgem mõõde. Väljund võrdub uue funktsioonikaardi punktkorrutisega. Ülaltoodud meetodist lähtudes peate:
- Muutke x1 ja x2 uude dimensiooni
- Arvutage punktkorrutis: ühine kõigile tuumadele
- Muutke x1 ja x2 uude dimensiooni
Kõrgema mõõtme arvutamiseks saate kasutada ülaltoodud funktsiooni.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Väljund
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Arvutage punktkorrutis
Saate kasutada objekti punkti numpyst, et arvutada punktide korrutis esimese ja teise vektori vahel, mis on salvestatud x_1-sse.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Väljund on 8100. Näete probleemi, peate punktkorrutise arvutamiseks mällu salvestama uue funktsioonikaardi. Kui teil on miljonite kirjetega andmestik, on see arvutuslikult ebaefektiivne.
Selle asemel võite kasutada polünoomtuum punktkorrutise arvutamiseks vektorit teisendamata. See funktsioon arvutab x1 ja x2 punktkorrutise nii, nagu oleks need kaks vektorit teisendatud kõrgemasse dimensiooni. Teisiti öeldes arvutab kerneli funktsioon punktprodukti tulemused teisest funktsiooniruumist.
Polünoomilise kerneli funktsiooni saab sisse kirjutada Python nagu järgida.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
See on kahe vektori punktkorrutise võimsus. Allpool tagastate polünoomituuma teise astme. Väljund on võrdne teise meetodiga. See on tuuma võlu.
polynomial_kernel(x1, x2, p=2) 8100
Kerneli meetodite tüübid
Saadaval on palju erinevaid Kerneli tehnikaid. Lihtsaim on lineaarne tuum. See funktsioon töötab teksti klassifitseerimisel üsna hästi. Teine tuum on:
- Polünoomtuum
- Gaussi tuum
Näites koos TensorFlow, kasutame juhuslikku Fourier'd. TensorFlow'l on uue funktsiooniruumi arvutamiseks sisseehitatud hindaja. Gaussi filtri funktsioon on Gaussi tuuma funktsiooni ligikaudne funktsioon.
Gaussi filtreerimisfunktsioon arvutab välja andmepunktide sarnasuse palju suurema mõõtmega ruumis.
Treenige Gaussi tuuma klassifikaatorit TensorFlow abil
Algoritmi eesmärk on klassifitseerida leibkond, kes teenib rohkem või vähem kui 50 XNUMX.
Hindate logistilist tuuma regressiooni masinõpet, et saada võrdlusmudel. Pärast seda treenite Kerneli klassifikaatorit, et näha, kas saate paremaid tulemusi.
Kasutate täiskasvanutele mõeldud andmestikust järgmisi muutujaid.
- vanus
- tööklass
- fnlwgt
- haridus
- hariduse_nr
- abielu-
- okupatsioon
- suhe
- rass
- sugu
- kapitalikasum
- kapitali_kahjum
- tundi_nädal
- kodumaa
- etikett
Enne mudeli treenimist ja hindamist toimige järgmiselt.
- Samm 1) Importige teegid
- Samm 2) Importige andmed
- Samm 3) Valmistage andmed ette
- Samm 4) Koostage sisend_fn
- 5. samm) Looge logistiline mudel: lähtemudel
- 6. samm) hinnake mudelit
- Samm 7) Koostage Kerneli klassifikaator
- Samm 8) Hinnake Kerneli klassifikaatorit
Step 1) Importige raamatukogud
Kerneli mudelite importimiseks ja koolitamiseks Tehisintellekt, peate importima tensorflow, pandas ja tuim
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Step 2) Importige andmed
Andmed laadite alla järgmiselt veebisait ja impordite selle panda andmeraamina.
## 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)
Nüüd, kui rong ja katsekomplekt on määratletud, saate muuta veeru sildi stringist täisarvuks. tensorflow ei aktsepteeri sildi stringi väärtust.
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)
Step 3) Valmistage andmed ette
Andmekogum sisaldab nii pidevaid kui ka kategoorilisi tunnuseid. Hea tava on pidevate muutujate väärtuste standardimine. Saate kasutada sci-kit learning funktsiooni StandardScaler. Rongi ja katsekomplekti teisendamiseks loote ka kasutaja määratud funktsiooni. Pange tähele, et ühendate pidevad ja kategoorilised muutujad ühisesse andmekogumisse ja massiiv peaks olema tüüpi: 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
Trafo funktsioon on valmis, saate teisendada andmestiku ja luua funktsiooni 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)
Järgmises etapis treenite logistilist regressiooni. See annab teile algtaseme täpsuse. Eesmärk on ületada lähtejoon teise algoritmi, nimelt Kerneli klassifikaatoriga.
Step 4) Looge logistiline mudel: baasmudel
Funktsiooni veeru koostate objektiga tegelik_väärtusega_veerg. See tagab, et kõik muutujad on tihedad arvandmed.
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
Hindaja defineeritakse TensorFlow Estimatori abil, saate määrata funktsioonide veerud ja graafiku salvestamise koha.
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}
Te treenite logistilist regressiooni, kasutades minipartiisid suurusega 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)
Saate mudelit treenida 1.000 iteratsiooniga
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>
Step 6) Hinnake mudelit
Mudeli hindamiseks määratlete numpy hindaja. Kasutate hindamiseks kogu andmestikku
# 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}
Teie täpsus on 82 protsenti. Järgmises jaotises proovite ületada logistilist klassifikaatorit Kerneli klassifikaatoriga
Step 7) Koostage Kerneli klassifikaator
Kerneli hindaja ei erine vähemalt ehituse poolest nii palju traditsioonilisest lineaarsest klassifikaatorist. Idee on kasutada selgesõnalise kerneli võimsust lineaarse klassifikaatoriga.
Kerneli klassifikaatori koolitamiseks vajate TensorFlow's saadaval olevat kahte eelmääratletud hinnangut:
- RandomFourierFeatureMapper
- KernelLinearClassifier
Esimeses jaotises õppisite, et peate kerneli funktsiooni abil muutma madala mõõtme kõrgeks mõõtmeks. Täpsemalt kasutate juhuslikku Fourier'd, mis on Gaussi funktsiooni ligikaudne väärtus. Õnneks on Tensorflow teegis funktsioon: RandomFourierFeatureMapper. Mudelit saab treenida hindaja KernelLinearClassifier abil.
Mudeli koostamiseks toimige järgmiselt.
- Seadistage suure mõõtmega Kerneli funktsioon
- Määrake L2 hüperparameeter
- Ehitage mudel
- Treeni modelli
- Hinnake mudelit
samm A) Seadistage suure mõõtmega Kerneli funktsioon
Praegune andmestik sisaldab 14 funktsiooni, mille teisendate 5.000-mõõtmelise vektori uueks kõrgeks mõõtmeks. Teisenduse saavutamiseks kasutate juhuslikke Fourier funktsioone. Kui tuletate meelde Gaussi tuuma valemit, märkate, et määratleda tuleb standardhälbe parameeter. See parameeter kontrollib klassifitseerimisel kasutatavat sarnasuse mõõdikut.
Saate kõiki RandomFourierFeatureMapperi parameetreid häälestada järgmiste funktsioonidega:
- sisend_dim = 14
- väljundi_dim = 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Peate konstrueerima kerneli kaardistaja, kasutades varem loodud funktsioonide veerge: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
samm B) Määrake L2 hüperparameeter
Ülepaigutamise vältimiseks karistate kaotusfunktsiooni L2 regulaatoriga. Seadsite L2 hüperparameetri väärtuseks 0.1 ja õppimiskiiruseks 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
samm C) Ehitage mudel
Järgmine samm sarnaneb lineaarse klassifikatsiooniga. Kasutate sisseehitatud hindajat KernelLinearClassifier. Pange tähele, et lisate eelnevalt määratletud kerneli kaardistaja ja muudate mudelikataloogi.
### 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'}
samm D) Treeni modelli
Nüüd, kui Kerneli klassifikaator on loodud, olete valmis seda koolitama. Valite mudeli kordamise 2000 korda
### 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>]}})
samm E) Hinnake mudelit
Viimaseks, kuid mitte vähem tähtsaks, hindate oma mudeli toimivust. Sa peaksid suutma ületada logistilise regressiooni.
# 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
Lõplik täpsus on 84%, see on 2% paremus võrreldes logistilise regressiooniga. Täpsuse paranemise ja arvutuskulude vahel on kompromiss. Peate mõtlema, kas 2% paranemine on väärt erinevate klassifikaatorite kulutatud aega ja kas sellel on teie ettevõttele veenev mõju.
kokkuvõte
Kernel on suurepärane tööriist mittelineaarsete andmete (peaaegu) lineaarseks muutmiseks. Selle meetodi puuduseks on see, et see on arvutuslikult aeganõudev ja kulukas.
Altpoolt leiate kõige olulisema koodi tuuma klassifikaatori koolitamiseks
Seadistage suure mõõtmega Kerneli funktsioon
- sisend_dim = 14
- väljundi_dim = 5000
- stddev=4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Määrake L2 hüperparameeter
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Ehitage mudel
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
Treeni modelli
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
Hinnake mudelit
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
