Gaussi tuum masinõppes: tuumameetodite näited

Lang L: none (table-of-contents):

Anonim

Selle õpetuse eesmärk on muuta andmekogum lineaarselt eraldatavaks. Õpetus on jagatud kaheks osaks:

  1. Funktsiooni teisendamine
  2. Tensorflow abil saate koolitada tuuma klassifikaatorit

Esimeses osas saate aru tuumameetodi ideest masinõppes, teises osas aga näete, kuidas Tensorflow abil tuuma klassifikaatorit koolitada. Kasutate täiskasvanute andmestikku. Selle andmekogumi eesmärk on klassifitseerida tulu alla 50 k ja üle selle, teades iga leibkonna käitumist.

Selles õpetuses saate teada

  • Miks vajate Kerneli meetodeid?
  • Mis on tuum masinõppes?
  • Tuumameetodite tüübid
  • Rongi Gaussi tuuma klassifikaator koos TensorFlow'ga

Miks vajate Kerneli meetodeid?

Iga klassifikaatori eesmärk on klassid õigesti ennustada. Selleks peaks andmekogum olema eraldatav. Vaadake krunti allpool; on üsna lihtne näha, et kõik musta joone kohal olevad punktid kuuluvad esimesse klassi ja teised punktid teise klassi. Sellise lihtsa andmekogumi olemasolu on aga äärmiselt haruldane. Enamasti pole andmed eraldatavad. Tuumameetodid masinõppes annavad naiivsetele klassifikaatoritele nagu logistiline regressioon raske aja.

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

Alloleval joonisel joonistame andmekogumi, mida ei saa lineaarselt eraldada. Kui tõmbame sirge joone, ei klassifitseerita enamikku punkte õigesse klassi.

Üks viis selle probleemiga tegelemiseks on võtta andmekogum ja teisendada andmed teise funktsioonikaardile. See tähendab, et kasutate teise plaani andmete teisendamiseks funktsiooni, 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 joonise andmed on 2D Gaussi tuuma plaanis, mida ei saa lahutada. Võite proovida neid andmeid kolmemõõtmelisena teisendada, see tähendab, et loote kolme teljega joonise.

Gaussi tuuma näites rakendame oma andmete 3D-mõõtmesse viimiseks polünoomide kaardistamist. Andmete teisendamise valem on järgmine.

Uute funktsioonikaartide loomiseks määrate funktsiooni Gaussi tuuma Pythonis

Nupu abil saate ülaltoodud valemi kodeerida:

Valem Samaväärne Numpy kood
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

Uus kaardistamine peaks olema 3-mõõtmeline 16 punktiga

x_1 = mapping(x, y)x_1.shape 
(3, 16)

Teeme uue joonise vastavalt 3 teljega, vastavalt x, y ja 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()

Me näeme paranemist, kuid kui muuta graafiku suunda, on selge, et andmekogum on nüüd eraldatav

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

Suure andmekogumi manipuleerimiseks ja peate võib-olla looma rohkem kui 2 dimensiooni, peate ülaltoodud meetodi abil silmitsi suure probleemiga. Tegelikult peate muutma kõik andmepunktid, mis pole ilmselgelt jätkusuutlik. See võtab teid vanuses ja teie arvutil võib mälu otsa saada.

Kõige tavalisem viis selle probleemi lahendamiseks on kerneli kasutamine .

Mis on tuum masinõppes?

Idee on kasutada kõrgema mõõtmega funktsiooniruumi, et muuta andmed peaaegu lineaarselt eraldatavaks, nagu on näidatud ülaltoodud joonisel.

Andmepunktide eraldamiseks on palju kõrgemate mõõtmetega ruume. Näiteks oleme näidanud, et polünoomide kaardistamine on suurepärane algus.

Samuti oleme näidanud, et paljude andmete korral pole see teisendamine tõhus. Selle asemel saate masinõppes kasutada tuuma funktsiooni, et andmeid muuta ilma uuele funktsiooniplaanile muutmata.

Tuuma võlu on leida funktsioon, mis väldib kõiki probleeme, mis kaasnevad kõrgemõõtmelise arvutusega. Tuuma tulemus on skalaar või öeldes teisiti, oleme tagasi ühemõõtmelises ruumis

Pärast selle funktsiooni leidmist saate selle ühendada tavalise lineaarse klassifikaatoriga.

Vaatame näite tuuma masinõppe mõiste mõistmiseks. Teil on kaks vektorit x1 ja x2. Eesmärk on polünoomkaardistamise abil luua kõrgem mõõde. Väljund võrdub uue funktsioonikaardi punkttootega. Ülaltoodud meetodi põhjal peate:

  1. Teisendage x1 ja x2 uueks dimensiooniks
  2. Arvutage punktitoode: ühine kõigile tuumadele
  3. Teisendage x1 ja x2 uueks dimensiooniks

Kõrgema dimensiooni arvutamiseks võite kasutada ülaltoodud funktsiooni.

## Kernelx1 = 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 punktitoote

Objektipunkti numpy abil saate arvutada punktitoote x_1-sse salvestatud esimese ja teise vektori vahel.

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

Väljund on 8100. Näete probleemi, punkttoote arvutamiseks peate mällu salvestama uue funktsioonikaardi. Kui teil on miljonite kirjetega andmekogum, on see arvutuslikult ebaefektiivne.

Selle asemel võite kasutada polünoomi tuuma punkttoote arvutamiseks ilma vektorit teisendamata. See funktsioon arvutab punktide x1 ja x2 korrutise nii, nagu oleksid need kaks vektorit teisendatud kõrgemasse dimensiooni. Teisiti öeldes arvutab kernli funktsioon punktitoote tulemused teisest funktsiooniruumist.

Pyynonis saate polünoomi kerneli funktsiooni kirjutada järgmiselt.

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

See on kahe vektori punkti korrutise jõud. Allpool tagastate polünoomi tuuma teise astme. Väljund on võrdne teise meetodiga. See on tuuma võlu.

polynomial_kernel(x1, x2, p=2)8100

Tuumameetodite tüübid

Saadaval on palju erinevaid kerneli tehnikaid. Lihtsaim on lineaarne kernel. See funktsioon töötab teksti liigitamisel üsna hästi. Teine tuum on:

  • Polünoomne kernel
  • Gaussi tuum

TensorFlow näites kasutame juhuslikku Fourieri. TensorFlow'l on uue funktsiooniruumi arvutamiseks sisseehitatud hindaja. Gaussi filtri funktsioon on ligikaudne Gaussi kerneli funktsioon.

Gaussi filtreerimisfunktsioon arvutab andmepunktide sarnasuse palju suurema mõõtmetega ruumis.

Rongi Gaussi tuuma klassifikaator koos TensorFlow'ga

Algoritmi eesmärk on klassifitseerida leibkond, kes teenib rohkem kui 50 000.

Hindate võrdlusmudeli saamiseks logistilist kerneli regressioonimasina õppimist. Pärast seda koolitate kerneli klassifikaatorit, et näha, kas saate paremaid tulemusi.

Kasutate järgmisi täiskasvanute andmestiku muutujaid:

  • vanus
  • tööklass
  • fnlwgt
  • haridus
  • haridus_num
  • abieluline
  • okupatsioon
  • suhe
  • võistlus
  • sugu
  • kapital_kasum
  • kapitali_kaotus
  • tundi_nädal
  • päritoluriik
  • silt

Enne mudeli koolitamist ja hindamist jätkate järgmiselt:

  • 1. samm. Importige teegid
  • 2. samm. Importige andmed
  • 3. samm. Valmistage andmed ette
  • 4. samm. Ehitage sisend_fn
  • Samm 5) Konstrueerige logistiline mudel: lähtemudel
  • Samm 6) Hinnake mudelit
  • Samm 7) Ehitage kerneli klassifikaator
  • 8. samm. Hinnake tuuma klassifikaatorit

1. samm. Importige teegid

Kerneli mudelite importimiseks ja koolitamiseks tehisintellektis peate importima tensorflow, pandad ja numpy

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

2. samm. Importige andmed

Laadite andmed alla järgmiselt veebisaidilt ja impordite need panda andmekaadrina.

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

Nüüd, kui rong ja testikomplekt 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)

3. samm. Valmistage andmed ette

Andmekogum sisaldab nii pidevaid kui ka kategoorilisi tunnuseid. Hea tava on pidevate muutujate väärtuste standardiseerimine. Võite kasutada sci-kit õppida funktsiooni StandardScaler. Rongi ja testikomplekti teisendamise hõlbustamiseks loote ka kasutaja määratletud funktsiooni. Pange tähele, et liidate pidevad ja kategoorilised muutujad ühiseks andmekogumiks ning massiivi tüüp peaks olema: 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

Trafo funktsioon on valmis, saate teisendada andmekogumi 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 algtase erineva algoritmiga, nimelt kerneli klassifikaatoriga.

Samm 4) Konstrueerige logistiline mudel: lähtemudel

Funktsiooni veeru koostate objektiga real_valued_column. See tagab, et kõik muutujad on tihedad arvandmed.

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

Hindaja määratakse TensorFlow Estimatori abil, juhendate funktsiooniveerge ja graafiku salvestamise kohta.

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}

Treenite logisitc regressiooni, kasutades 200-suuruseid miniparteid.

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

Mudeli saab treenida 1000 kordusega

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.

Samm 6) Hinnake mudelit

Mudeli hindamiseks määrate numpy hinnangu. Hindamiseks kasutate kogu andmekogumit

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

Teie täpsus on 82 protsenti. Järgmises jaotises proovite logistilist klassifikaatorit võita kerneli klassifikaatoriga

Samm 7) Ehitage kerneli klassifikaator

Tuuma hindaja ei erine vähemalt ehituslikult nii traditsioonilisest lineaarsest klassifikaatorist. Idee on kasutada selgesõnalise tuuma jõudu koos lineaarse klassifikaatoriga.

Kerneli klassifikaatori koolitamiseks vajate TensorFlow'is saadaval kahte eelnevalt määratletud hindajat:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Esimeses jaotises õppisite, et peate kerneli funktsiooni abil muutma madala dimensiooni kõrgeks dimensiooniks. Täpsemalt kasutate juhuslikku Fourieri, mis on ligikaudne funktsioon Gaussi funktsioonist. Õnneks on Tensorflow raamatukogus funktsioon: RandomFourierFeatureMapper. Mudelit saab koolitada hindaja KernelLinearClassifier abil.

Mudeli koostamiseks järgige neid samme:

  1. Määrake kõrgemõõtmeline kerneli funktsioon
  2. Määrake hüperparameeter L2
  3. Ehitage mudel
  4. Treenige mudelit
  5. Hinnake mudelit

Samm A) Määrake kõrgemõõtmeline kerneli funktsioon

Praegune andmekogum sisaldab 14 funktsiooni, mille teisendate 5000-mõõtmelise vektori uueks kõrgeks mõõtmeks. Teisenduse saavutamiseks kasutate juhuslikke Fourieri funktsioone. Kui tuletate meelde Gaussi tuuma valemit, märkite, et määratleda on standardhälbe parameeter. Selle parameetri juhtnupud sarnasuse mõõtmiseks kasutatakse klassifitseerimise ajal.

RandomFourierFeatureMapperi kõiki parameetreid saate häälestada järgmiselt:

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

Peate konstrueerima tuuma kaardistaja, kasutades varem loodud funktsiooniveerge: feat_column

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

Samm B) Määrake hüperparameeter L2

Ülekinnitamise vältimiseks karistate kaotusfunktsiooni L2 regulaatoriga. Te määrate hüperparameetri L2 väärtuseks 0,1 ja õppimise määraks 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 tuuma kaardistaja ja muudate mudeli kataloogi.

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

Samm D) Treenige mudelit

Nüüd, kui tuuma klassifikaator on üles ehitatud, olete valmis seda koolitama. Te valite mudeli kordamise 2000 korda

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

Etapp E) Hinnake mudelit

Viimasena, kuid mitte vähem tähtsana, hindate oma mudeli jõudlust. Peaksite suutma võita logistilise regressiooni.

# 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

Lõplik täpsus on 84%, see on logistilise regressiooniga võrreldes 2% parem. Täpsuse paranemise ja arvutusliku kulu vahel on kompromiss. Peate mõtlema, kas 2% paranemine on väärt erineva klassifikaatori kulutatud aega ja kas see mõjutab teie ettevõtet veenvalt.

Kokkuvõte

Tuum on suurepärane vahend mittelineaarsete andmete teisendamiseks (peaaegu) lineaarseks. Selle meetodi puuduseks on see, et see on arvutuslikult aeganõudev ja kulukas.

Altpoolt leiate kõige olulisema koodi kerneli klassifitseerija koolitamiseks

Määrake kõrgemõõtmeline kerneli funktsioon

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

Määrake hüperparameeter L2

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

Treenige mudelit

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

Hinnake mudelit

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