Gauss-kernel a gépi tanulásban: Python Kernel Methods

Ennek az oktatóanyagnak az a célja, hogy egy adatkészletet lineárisan elválaszthatóvá tegyen. Az oktatóanyag két részre oszlik:

Funkció átalakítás
Tanítson meg egy Kernel osztályozót a Tensorflow segítségével

Az első részben meg fogja érteni a gépi tanulás rendszermag-módszerének gondolatát, míg a második részben azt fogja látni, hogyan kell tanítani egy kernelosztályozót a Tensorflow segítségével. Ön a felnőtt adatkészletet fogja használni. Ennek az adathalmaznak az a célja, hogy az egyes háztartások viselkedésének ismeretében besorolja az 50 ezer alatti és feletti bevételt.

Miért van szükség Kernel Methodsokra?

Minden osztályozó célja az osztályok helyes előrejelzése. Ehhez az adatkészletnek szétválaszthatónak kell lennie. Nézze meg az alábbi cselekményt; meglehetősen egyszerű belátni, hogy a fekete vonal feletti összes pont az első osztályba tartozik, a többi pont pedig a második osztályba. Rendkívül ritka azonban az ilyen egyszerű adatkészlet. A legtöbb esetben az adatok nem különíthetők el. A Machine Learning rendszermag-módszerei megnehezítik az olyan naiv osztályozókat, mint a logisztikus regresszió.

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

Az alábbi ábrán egy olyan adatkészletet ábrázolunk, amely nem lineárisan szétválasztható. Ha egyenest húzunk, akkor a legtöbb pont nem a megfelelő osztályba kerül besorolásra.

A probléma megoldásának egyik módja az, hogy az adatkészletet egy másik jellemzőtérképre alakítja át. Ez azt jelenti, hogy egy függvényt fog használni az adatok egy másik tervbe történő átalakításához, 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 Gauss-kernel tervben vannak, amely nem választható el. Megpróbálhatja ezeket az adatokat háromdimenziósan transzformálni, ami azt jelenti, hogy 3 tengelyes ábrát készít.

A Gauss-kernel példánkban polinomiális leképezést alkalmazunk, hogy adatainkat 3D dimenzióba hozzuk. Az adatok átalakításának képlete a következő.

Függvényt a Gauss-kernelben definiál Python az új tereptérképek létrehozásához

Használhatja számtalan a fenti képlet kódolásához:

Képlet	Egyenértékű Numpy kód
x	x[:,0]**
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	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

Az új leképezésnek 3 dimenziósnak kell lennie, 16 ponttal

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Készítsünk egy új, 3 tengelyű, x, y és z tengelyű diagramot.

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

Látunk javulást, de ha megváltoztatjuk a diagram tájolását, egyértelmű, hogy az adatkészlet most szétválasztható

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

Egy nagy adatkészlet manipulálásához, és előfordulhat, hogy 2-nél több dimenziót kell létrehoznia, nagy problémával kell szembenéznie a fenti módszerrel. Valójában minden adatpontot át kell alakítani, ami nyilvánvalóan nem fenntartható. Időbe telik, és előfordulhat, hogy a számítógép memóriája elfogy.

A probléma megoldásának legáltalánosabb módja az a mag.

Mi az a kernel a gépi tanulásban?

Az ötlet az, hogy egy nagyobb dimenziójú jellemzőteret használjunk, hogy az adatok szinte lineárisan elkülöníthetők legyenek, amint az a fenti ábrán látható.

Rengeteg magasabb dimenziójú tér található az adatpontok elkülöníthetővé tételéhez. Például megmutattuk, hogy a polinomiális leképezés nagyszerű kezdet.

Azt is bebizonyítottuk, hogy sok adat birtokában ezek az átalakítások nem hatékonyak. Ehelyett a Machine Learning rendszermag-függvényét használhatja az adatok módosításához anélkül, hogy új szolgáltatástervre váltana.

A kernel varázslata abban rejlik, hogy talál egy függvényt, amely elkerüli a nagydimenziós számításokból eredő összes problémát. A kernel eredménye egy skalár, vagy másként mondva visszatérünk az egydimenziós térhez

Miután megtalálta ezt a függvényt, csatlakoztathatja a szabványos lineáris osztályozóhoz.

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

Alakítsa át x1-et és x2-t új dimenzióvá
Számítsa ki a pontszorzatot: közös minden kernelre
Alakítsa át x1-et és x2-t új dimenzióvá

A magasabb dimenzió kiszámításához használhatja a fent létrehozott függvényt.

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

teljesítmény

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

Számítsa ki a pontszorzatot!

A numpy objektumpont segítségével kiszámíthatja az x_1-ben tárolt első és második vektor közötti pontszorzatot.

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

A kimenet 8100. Látja a problémát, el kell tárolnia a memóriában egy új jellemzőtérképet a pontszorzat kiszámításához. Ha több millió rekordot tartalmazó adatkészlettel rendelkezik, az számítási szempontból nem hatékony.

Ehelyett használhatja a polinom kernel a pontszorzat kiszámításához a vektor transzformációja nélkül. Ez a függvény úgy számítja ki az x1 és x2 pontszorzatát, mintha ezt a két vektort a magasabb dimenzióba transzformálták volna. Másképp mondva, a kernelfüggvény egy másik jellemzőtérből számítja ki a pontszorzat eredményeit.

Beírhatod a polinomiális kernelfüggvényt Python a következőképpen.

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

Ez két vektor pontszorzatának hatványa. Az alábbiakban visszaadja a polinom kernel második fokát. A kimenet megegyezik a másik módszerrel. Ez a kernel varázsa.

polynomial_kernel(x1, x2, p=2)			
8100

Kernel-módszerek típusai

Számos különféle kernel technika áll rendelkezésre. A legegyszerűbb a lineáris kernel. Ez a funkció elég jól működik szövegosztályozáshoz. A másik kernel:

Polinom kernel
Gauss kernel

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

A Gauss-szűrő függvény kiszámítja a hasonlóságot az adatpontok között egy sokkal magasabb dimenziós térben.

A Gauss-kernel osztályozó képzése a TensorFlow segítségével

Az algoritmus célja az 50 ezernél többet vagy kevesebbet kereső háztartás osztályozása.

Értékelni fogja a logisztikai kernel regressziós gépi tanulást, hogy benchmark modellje legyen. Ezt követően betanít egy kernel osztályozót, hogy lássa, jobb eredményeket érhet el.

A következő változókat használja a felnőtt adatkészletből:

kor
munkaosztály
fnlwgt
szabott oktatás
oktatási_szám
házastársi
foglalkozás
kapcsolat
verseny
szex
tőkenyereség
tőke_veszteség
óra_hét
Szülőföld
címke

A modell betanítása és értékelése előtt az alábbiak szerint járjon el:

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) Szerkessze meg az input_fn értéket
5. lépés) Építse meg 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

Step 1) Importálja a könyvtárakat

Kernel modellek importálásához és betanításához Mesterséges intelligencia , importálnia kell a tensorflow-t, pandák és zsibbadt

#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) Importálja az adatokat

Az adatokat a következőkről töltheti le és panda adatkeretként importálja.

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

Most, hogy a vonat és a tesztkészlet definiálva van, megváltoztathatja az oszlopcímkét karakterláncról egész számra. A tensorflow nem fogad el karakterlánc-értéket 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)

Step 3) Készítse elő az adatokat

Az adatkészlet folyamatos és kategorikus jellemzőket is tartalmaz. Jó gyakorlat a folytonos változók értékeinek szabványosítása. Használhatja a sci-kit learning StandardScaler funkcióját. Létrehozhat egy felhasználó által definiált függvényt is, amely megkönnyíti a vonat és a tesztkészlet konvertálását. Vegye figyelembe, hogy a folytonos és kategorikus változókat egy közös adathalmazba kell összefűzni, é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 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

A transzformátor funkció készen áll, konvertálhatja 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 logisztikus regressziót fog gyakorolni. Ez megadja az alapvonal pontosságát. A cél az alapvonal legyőzése egy másik algoritmussal, nevezetesen egy kernel osztályozóval.

Step 4) A logisztikai modell megalkotása: Alapmodell

A jellemzőoszlopot a valós_értékű_oszlop objektummal kell létrehozni. Biztosítani fogja, hogy minden változó sűrű numerikus adat legyen.

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

A becslő a TensorFlow Becslő segítségével definiálható, Ön megadja a jellemző oszlopokat és a grafikon mentésének 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': <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}

A logisztikai regressziót 200-as méretű mini kötegekkel fogja gyakorolni.

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

A modell 1.000 iterációval betanítható

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) Értékelje a modellt

Meghatározza a numpy becslést a modell értékeléséhez. A teljes adatkészletet használja az értékeléshez

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

82 százalékos a pontossága. A következő részben megpróbálja legyőzni a logisztikai osztályozót egy Kernel osztályozóval

Step 7) Szerkessze meg a Kernel osztályozót

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

A Kernel osztályozó betanításához két előre meghatározott becslőre van szüksége a TensorFlow-ban:

RandomFourierFeatureMapper
KernelLinearClassifier

Az első részben megtanulta, hogy az alacsony dimenziót magas dimenzióvá kell átalakítania egy kernelfü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 a következő funkcióval rendelkezik a könyvtárában: RandomFourierFeatureMapper. A modell a KernelLinearClassifier becslő segítségével betanítható.

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

Állítsa be a nagy dimenziójú Kernel funkciót
Állítsa be az L2 hiperparamétert
Építsd meg a modellt
Tanítsd meg a modellt
Értékelje a modellt

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

A jelenlegi adatkészlet 14 jellemzőt tartalmaz, amelyeket az 5.000 dimenziós vektor új magas dimenziójává alakít. A transzformáció eléréséhez a véletlenszerű Fourier-jellemzőket használja. Ha felidézi a Gauss-kernel képletet, megjegyzi, hogy meg kell határozni a szórás paramétert. Ez a paraméter az osztályozás során alkalmazott hasonlósági mértéket vezérli.

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

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

A kernelleképezőt a feat_column előtt létrehozott jellemzőoszlopok felhasználásával kell létrehoznia

### Map Kernel
kernel_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ályosítóval szankcionálja 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 Építsd meg a modellt

A következő lépés hasonló a lineáris osztályozáshoz. A beépített KernelLinearClassifier becslőt használja. Vegye figyelembe, hogy hozzáadja a korábban meghatározott kernelleképezőt, és módosítja a modellkönyvtárat.

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

D) lépés Tanítsd meg a modellt

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

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

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

Végül, de nem utolsósorban értékeli modellje teljesítményét. Le kell tudnia győzni a logisztikai regressziót.

# 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

A végső pontosság 84%, ez 2%-os javulás a logisztikus regresszióhoz képest. Kompromisszum van a pontosság javulása és a számítási költségek között. Gondolkodnia kell, hogy a 2%-os fejlesztés megéri-e a különböző osztályozók által eltöltött időt, és van-e meggyőző hatása az Ön vállalkozására.

Összegzésként

A kernel nagyszerű eszköz a nemlineáris adatok (majdnem) lineárissá alakítására. Ennek a módszernek a hiányossága, hogy számításilag időigényes és költséges.

Az alábbiakban megtalálja a legfontosabb kódot a kernel osztályozó betanításához

Állítsa be a nagy dimenziójú 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")

Tanítsd meg 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)

Talán tetszene:

Miért van szükség Kernel Methodsokra?

KAPCSOLÓDÓ CIKKEK

Mi az a kernel a gépi tanulásban?

Kernel-módszerek típusai

A Gauss-kernel osztályozó képzése a TensorFlow segítségével

Összegzésként