Gaussian Kernel a gépi tanulásban: Példák a rendszermagra

A bemutató célja egy adatkészlet lineárisan elkülöníthetővé tétele. Az oktatóanyag két részre oszlik:

1. Funkció átalakítás
2. Képezzen egy Kernel osztályozót a Tensorflow segítségével

Az első részben meg fogja érteni a gépi tanulás kernelmódszerének gondolatát, míg a második részben azt látja, hogyan kell betanítani a kernelbontót a Tensorflow segítségével. A felnőttek adatkészletét fogja használni. Ennek az adatkészletnek az a célja, hogy az egyes háztartások viselkedésének ismeretében osztályozza a bevételeket 50 ezer alatt és felett.

Ebben az oktatóanyagban megtanulja-

• Miért van szükség a Kernel módszerekre?
• Mi a rendszermag a gépi tanulásban?
• A kernelmódszerek típusai
• Vonat Gaussian Kernel osztályozója a TensorFlow segítségével

Miért van szükség a Kernel módszerekre?

Minden osztályozó célja az osztályok helyes előrejelzése. Ehhez az adatkészletnek elkülöníthetőnek kell lennie. Nézd meg az alábbi cselekményt; meglehetősen egyszerű látni, hogy a fekete vonal felett minden pont az első osztályba tartozik, a többi pont pedig a második osztályba tartozik. Rendkívül ritka az ilyen egyszerű adatkészlet. A legtöbb esetben az adatok nem választhatók el egymástól. A gépi tanulás rendszermag-módszerei nehéz feladatokat okoznak a logikai regresszióhoz hasonló naiv osztályozóknak.

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

Az alábbi ábrán egy olyan adatkészletet ábrázolunk, amely nem lineárisan választható szét. Ha egyeneset húzunk, akkor a legtöbb pontot nem a megfelelő osztályba soroljuk.

A probléma megoldásának egyik módja az adatkészlet felvétele és az adatok átalakítása egy másik jellemző térképen. Ez azt jelenti, hogy egy függvény segítségével átalakítja az adatokat egy másik tervben, amelynek lineárisnak kell lennie.

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

A fenti ábra adatai egy 2D-s Gauss-rendszermag tervben vannak, amely nem választható el. Megpróbálhatja ezeket az adatokat háromdimenziósan átalakítani, ez azt jelenti, hogy három tengellyel rendelkező ábrát hoz létre.

Gauss-rendszermag példánkban polinomiális leképezést alkalmazunk, hogy adataink 3D dimenzióba kerüljenek. Az adatok átalakítására szolgáló képlet a következő.

Megadhat egy függvényt a Gaussian Kernel Pythonban az új szolgáltatástérképek létrehozásához

A numpy segítségével kódolhatja a fenti képletet:

Képlet	Ekvivalens Numpy-kód
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

Az új leképezésnek 3 dimenzióval kell rendelkeznie, 16 ponttal

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Készítsünk egy új ábrát 3 tengellyel, x, y és 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() 

Látunk javulást, de ha megváltoztatjuk a diagram tájolását, akkor egyértelmű, hogy az adatkészlet már elválasztható

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

Nagy adatkészlet manipulálásához, és előfordulhat, hogy több mint 2 dimenziót kell létrehoznia, a fenti módszerrel nagy problémával kell szembenéznie. Valójában minden adatpontot átalakítania kell, ami nyilvánvalóan nem fenntartható. Életkorokba telik, és előfordulhat, hogy a számítógépén elfogy a memória.

A probléma legáltalánosabb módja a kernel használata .

Mi a rendszermag a gépi tanulásban?

Az elképzelés egy magasabb dimenziós teret kíván használni, hogy az adatok szinte lineárisan elválaszthatók legyenek, amint az a fenti ábrán látható.

Rengeteg nagyobb dimenziós tér van az adatpontok elkülöníthetővé tételéhez. Például megmutattuk, hogy a polinom leképezés nagyszerű kezdet.

Kimutattuk azt is, hogy sok adat birtokában ezek az átalakítás nem hatékony. Ehelyett használhatja a Kernel funkciót a Machine Learningben az adatok módosítására anélkül, hogy új szolgáltatástervre váltana.

A kernel varázslata egy olyan funkció megtalálása, amely elkerüli a nagydimenziós számítással járó összes problémát. A kernel eredménye egy skalár, vagy másképp mondva visszatértünk az egydimenziós térbe

Miután megtalálta ezt a funkciót, csatlakoztathatja a standard lineáris osztályozóhoz.

Nézzünk meg egy példát a Kernel Machine Learning fogalmának megértésére. Két vektorod van, x1 és x2. A cél egy magasabb dimenzió létrehozása polinomiális leképezéssel. A kimenet megegyezik az új funkciótérkép ponttermékével. A fenti módszerből a következőket kell tennie:

1. Alakítsa át x1 és x2 új dimenzióvá
2. Számítsa ki a dot terméket: minden kernel közös
3. Alakítsa át x1 és x2 új dimenzióvá

A fent létrehozott függvény segítségével kiszámíthatja a magasabb dimenziót.

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

Kimenet

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

Számítsa ki a dot szorzatot

Használhatja a numpy objektumpontot az x_1-ben tárolt első és második vektor közötti ponttermék kiszámításához.

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

A kimenet 8100. Látja a problémát, a ponttermék kiszámításához új funkciótérképet kell tárolnia a memóriában. Ha több millió rekordot tartalmazó adatkészlete van, az számítási szempontból hatástalan.

Ehelyett a polinom kernel segítségével kiszámíthatja a dot szorzót a vektor transzformálása nélkül. Ez a függvény úgy számítja ki az x1 és az x2 pontszorzatát, mintha ez a két vektor átalakult volna a magasabb dimenzióba. Másképp mondva, a kernel függvény kiszámítja a dot termék eredményeit egy másik jellemző térből.

A polynom kernel függvényt Pythonban a következőképpen írhatja.

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

Két vektor ponttermékének ereje. Az alábbiakban a polinom kernel második fokát adjuk vissza. A kimenet megegyezik a másik módszerrel. Ez a kernel varázsa.

polynomial_kernel(x1, x2, p=2)8100 

A kernelmódszerek típusai

Rengeteg különféle kernel technika áll rendelkezésre. A legegyszerűbb a lineáris kernel. Ez a funkció nagyon jól működik a szöveg osztályozásához. A másik kernel:

• Polinom kernel
• Gaussian Kernel

A TensorFlow példában a Random Fourier-t fogjuk használni. A TensorFlow beépített becslővel rendelkezik az új funkciótér kiszámításához. A Gauss-szűrő függvény a Gauss-kernel függvényének közelítése.

A Gauss-szűrési funkció kiszámítja az adatpontok hasonlóságát egy sokkal nagyobb dimenziós térben.

Vonat Gaussian Kernel osztályozója a TensorFlow segítségével

Az algoritmus célja a több mint 50 ezer kereső háztartás osztályozása.

Értékelni fogja egy logisztikai rendszermag-regressziós gépi tanulást, hogy legyen benchmark modellje. Ezt követően képez egy Kernel osztályozót, hátha jobb eredményeket érhet el.

A felnőtt változók következő változóit használja:

• kor
• munkahely
• fnlwgt
• oktatás
• oktatás_szám
• házassági
• Foglalkozása
• kapcsolat
• verseny
• szex
• tőkenyereség
• tőke_veszteség
• óra_ hét
• Szülőföld
• címke

Az alábbiak szerint jár el, mielőtt edz, és értékeli a modellt:

• 1. lépés: Importálja a könyvtárakat
• 2. lépés: Importálja az adatokat
• 3. lépés: Készítse elő az adatokat
• 4. lépés: Konstruálja az input_fn fájlt
• 5. lépés: Konstruálja a logisztikai modellt: Alapmodell
• 6. lépés) Értékelje a modellt
• 7. lépés: Készítse el a Kernel osztályozót
• 8. lépés: Értékelje a kernel osztályozót

1. lépés: Importálja a könyvtárakat

A Kernel-modellek importálásához és kiképzéséhez a Mesterséges Intelligenciában importálnia kell a tensorflow, a pandákat és a numpy-t

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

2. lépés: Importálja az adatokat

Az adatokat a következő webhelyről tölti le, és panda adatkeretként importálja.

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

Most, hogy a vonat és a tesztkészlet meg van határozva, megváltoztathatja az oszlop címkéjét string-ről egészre. A tensorflow nem fogadja el a karakterlánc értékét a címkéhez.

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. lépés: Készítse elő az adatokat

Az adatkészlet folyamatos és kategorikus jellemzőket egyaránt tartalmaz. Jó gyakorlat a folyamatos változók értékeinek egységesítése. Használhatja a sci-kit tanulás StandardScaler funkcióját. Hozzon létre egy felhasználó által definiált funkciót is, hogy megkönnyítse a vonat és a tesztkészlet átalakítását. Vegye figyelembe, hogy a folytonos és a kategorikus változókat összefűzi egy közös adatkészletbe, és a tömbnek a következő típusúnak kell lennie: 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 

A transzformátor funkció készen áll, átalakíthatja az adatkészletet, és létrehozhatja az input_fn függvényt.

X_train, y_train = prep_data_str(df_train)X_test, y_test = prep_data_str(df_test)print(X_train.shape)(32561, 14) 

A következő lépésben egy logisztikai regressziót fog kiképezni. Ez megadja az alappontosságot. A cél az alapvonal legyőzése egy másik algoritmussal, mégpedig egy Kernel osztályozóval.

4. lépés : Konstruálja a logisztikai modellt: Alapmodell

A jellemző oszlopot a real_valued_column objektummal állítja össze. Biztosítani fogja, hogy az összes változó sűrű numerikus adat legyen.

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

A becslőt a TensorFlow Estimator segítségével definiáljuk, Ön megadja a jellemző oszlopokat és a grafikon mentési helyét.

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} 

A logisitc regressziót 200 méretű mini-kötegekkel fogja edzeni.

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

Képezheti a modellt 1000 iterációval

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.

6. lépés) Értékelje a modellt

A modell kiértékeléséhez meghatározza a numerikus becslőt. A teljes adatkészletet használja az értékeléshez

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

Ön 82 százalékos pontossággal rendelkezik. A következő részben megpróbálja megverni a logisztikai osztályozót egy Kernel osztályozóval

7. lépés: Készítse el a Kernel osztályozót

A rendszermag-becslő nem különbözik annyira a hagyományos lineáris osztályozótól, legalábbis a felépítés szempontjából. Az ötlet az explicit kernel erejének felhasználása a lineáris osztályozóval.

Két előre definiált becslőre van szükség, amely elérhető a TensorFlow-ban a kernel-osztályozó képzéséhez:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Az első szakaszban megtanulta, hogy az alacsony dimenziót nagydimenzióvá kell alakítania egy kernel függvény segítségével. Pontosabban a Random Fourier-t fogja használni, amely a Gauss-függvény közelítése. Szerencsére a Tensorflow könyvtárában van egy funkció: RandomFourierFeatureMapper. A modell betanítható a KernelLinearClassifier becslő segítségével.

A modell felépítéséhez kövesse az alábbi lépéseket:

1. Állítsa be a nagy dimenziós Kernel funkciót
2. Állítsa be az L2 hiperparamétert
3. Építsd meg a modellt
4. Képezze ki a modellt
5. Értékelje a modellt

A lépés: Állítsa be a nagy dimenziós Kernel funkciót

A jelenlegi adatkészlet 14 olyan funkciót tartalmaz, amelyeket átalakít az 5000 dimenziós vektor új nagy dimenziójává. A véletlenszerű Fourier funkciókat használja az átalakítás eléréséhez. Ha felidézi a Gaussian Kernel képletet, akkor vegye figyelembe, hogy meg kell adni a szórás paramétert. Ez a paraméter-vezérlő a hasonlóságmérőhöz alkalmazandó az osztályozás során.

A RandomFourierFeatureMapper összes paraméterét a következőkkel hangolhatja:

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

A kerneltérképezőt az Feat_column előtt létrehozott jellemzőoszlopok használatával kell elkészítenie

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

B lépés: Állítsa be az L2 hiperparamétert

A túlillesztés elkerülése érdekében az L2 szabályozóval bünteti a veszteség funkciót. Az L2 hiperparamétert 0,1-re, a tanulási sebességet pedig 5-re állítja

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

C lépés: Készítse el a modellt

A következő lépés hasonló a lineáris osztályozáshoz. Használja a KernelLinearClassifier beépített becslőjét. Ne feledje, hogy hozzáadja a korábban definiált kerneltérképezőt, és megváltoztatja a modellkönyvtárat.

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

D lépés) Képezze ki a modellt

Most, hogy elkészült a Kernel osztályozó, készen áll arra, hogy betanítsa. Úgy dönt, hogy a modell 2000-szeresét ismétli

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

E. lépés) Értékelje a modellt

Végül, de nem utolsósorban értékeli a modell teljesítményét. Legyen képes legyőzni a logisztikai regressziót.

# 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

A végső pontosság 84%, ez 2% -os javulás a logisztikai regresszióhoz képest. Kompromisszum van a pontosság javítása és a számítási költség között. Arra kell gondolni, hogy 2% -os javulás megéri-e a különböző osztályozó által elfogyasztott időt, és hogy ez kényszerítő hatással van-e a vállalkozására.

Összegzés

A kernel nagyszerű eszköz a nemlineáris adatok (majdnem) lineárisokká történő átalakítására. Ennek a módszernek a hiányossága, hogy számítási szempontból időigényes és költséges.

Az alábbiakban megtalálja a legfontosabb kódot a rendszermag osztályozó képzéséhez

Állítsa be a nagy dimenziós Kernel funkciót

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

Állítsa be az L2 hiperparamétert

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

Építsd meg a modellt

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

Képezze ki a modellt

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

Értékelje a modellt

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