Gaussova jezgra u strojnom učenju: primjeri Kernel metoda

Sadržaj:

Anonim

Svrha ovog vodiča je učiniti skup podataka linearno odvojivim. Vodič je podijeljen u dva dijela:

  1. Transformacija značajke
  2. Obučite klasifikator jezgre s Tensorflowom

U prvom ćete dijelu razumjeti ideju koja stoji iza Kernel metode u strojnom učenju, dok ćete u drugom dijelu vidjeti kako trenirati klasifikator jezgre s Tensorflowom. Upotrijebit ćete skup podataka za odrasle. Cilj ovog skupa podataka je klasificirati prihod ispod i iznad 50 000, poznavajući ponašanje svakog kućanstva.

U ovom vodiču naučit ćete-

  • Zašto su vam potrebne metode jezgre?
  • Što je jezgra u strojnom učenju?
  • Vrste metoda jezgre
  • Obučite klasifikator Gaussove jezgre s TensorFlowom

Zašto su vam potrebne metode jezgre?

Cilj svakog klasifikatora je pravilno predvidjeti klase. Za to bi skup podataka trebao biti odvojen. Pogledajte zaplet ispod; prilično je jednostavno uočiti da sve točke iznad crne crte pripadaju prvoj klasi, a ostale točke drugoj klasi. Međutim, izuzetno je rijetko imati tako jednostavan skup podataka. Podaci se u većini slučajeva ne mogu razdvojiti. Metode jezgre u strojnom učenju teško daju naivnim klasifikatorima poput logističke regresije.

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

Na donjoj slici ucrtavamo skup podataka koji se ne može linearno odvojiti. Ako povučemo ravnu crtu, većina bodova neće biti svrstana u ispravnu klasu.

Jedan od načina rješavanja ovog problema je uzimanje skupa podataka i pretvaranje podataka u drugu mapu značajki. To znači da ćete koristiti funkciju za pretvaranje podataka u drugi plan, koji bi trebao biti prilagodljiv.

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

Podaci sa gornje slike nalaze se u 2D planu Gaussovih jezgri koji se ne može razdvojiti. Možete pokušati transformirati ove podatke u trodimenzionalnu, to znači da stvarate lik s 3 osi.

U našem primjeru Gaussove jezgre primijenit ćemo polinomno preslikavanje kako bismo doveli naše podatke u 3D dimenziju. Formula za transformaciju podataka je sljedeća.

U Gaussian Kernel Pythonu definirate funkciju za stvaranje novih mapa značajki

Možete koristiti numpy za kodiranje gornje formule:

Formula Ekvivalent Numpy koda
x x [:, 0] **
g 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

Novo mapiranje trebalo bi biti s 3 dimenzije sa 16 točaka

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

Napravimo novu plohu s 3 osi, x, y i 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()

Vidimo poboljšanje, ali ako promijenimo orijentaciju crteža, jasno je da je skup podataka sada odvojiv

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

Da biste manipulirali velikim skupom podataka i možda ćete morati stvoriti više od 2 dimenzije, suočit ćete se s velikim problemom pomoću gore navedene metode. U stvari, morate transformirati sve točke podataka, što očito nije održivo. Trebat će vam godine, a računalu će ponestati memorije.

Najčešći način za prevladavanje ovog problema je upotreba jezgre .

Što je jezgra u strojnom učenju?

Ideja je koristiti prostor značajki veće dimenzije kako bi se podaci učinili gotovo linearno odvojivima, kao što je prikazano na gornjoj slici.

Puno je prostora veće dimenzije kako bi se podatkovne točke učinile odvojivima. Na primjer, pokazali smo da je preslikavanje polinoma sjajan početak.

Također smo pokazali da s puno podataka ta transformacija nije učinkovita. Umjesto toga, možete koristiti funkciju jezgre u Strojnom učenju za izmjenu podataka bez promjene na novi plan značajki.

Magija jezgre je pronaći funkciju koja izbjegava sve probleme koje implicira visokodimenzionalno računanje. Rezultat jezgre je skalar, ili drugačije rečeno, vratili smo se u jednodimenzionalni prostor

Nakon što ste pronašli ovu funkciju, možete je priključiti na standardni linearni klasifikator.

Pogledajmo primjer za razumijevanje koncepta Kernel Machine Learninga. Imate dva vektora, x1 i x2. Cilj je stvoriti višu dimenziju pomoću polinomnog preslikavanja. Izlaz je jednak točkasti umnožak nove mape značajki. Iz gornje metode trebate:

  1. Pretvorite x1 i x2 u novu dimenziju
  2. Izračunajte točkasti proizvod: zajednički za sva jezgra
  3. Pretvorite x1 i x2 u novu dimenziju

Gore izrađenu funkciju možete koristiti za izračunavanje više dimenzije.

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

Izlaz

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

Izračunajte točkasti proizvod

Možete koristiti objektnu točku iz numpyja da biste izračunali umnožak točke između prvog i drugog vektora pohranjenog u x_1.

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

Izlaz je 8100. Vidite li problem, trebate pohraniti u memoriju novu mapu značajki da biste izračunali točkasti proizvod. Ako imate skup podataka s milijunima zapisa, računski je neučinkovit.

Umjesto toga, možete upotrijebiti polinomsku jezgru za izračunavanje umnoška točke bez transformacije vektora. Ova funkcija izračunava umnožak x1 i x2 kao da su ta dva vektora transformirana u višu dimenziju. Rečeno drugačije, funkcija jezgre izračunava rezultate točkanog proizvoda iz drugog prostora značajki.

Funkciju jezgra polinoma možete napisati u Pythonu kako slijedi.

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

To je snaga točkanog proizvoda dva vektora. Ispod vraćate drugi stupanj polinomske jezgre. Izlaz je jednak drugoj metodi. Ovo je čarolija jezgre.

polynomial_kernel(x1, x2, p=2)8100

Vrste metoda jezgre

Dostupno je puno različitih tehnika jezgre. Najjednostavniji je linearni kernel. Ova funkcija prilično dobro funkcionira za klasifikaciju teksta. Druga jezgra je:

  • Polinomska jezgra
  • Gaussova jezgra

U primjeru s TensorFlowom upotrijebit ćemo Random Fourier. TensorFlow ima ugrađeni procjenitelj za izračunavanje novog prostora značajki. Gaussova funkcija filtra aproksimacija je Gaussove funkcije jezgre.

Gaussova funkcija filtriranja izračunava sličnost između podatkovnih točaka u mnogo višem dimenzionalnom prostoru.

Obučite klasifikator Gaussove jezgre s TensorFlowom

Cilj algoritma je klasificirati kućanstvo koje zarađuje više ili manje od 50 tisuća kuna.

Procijenit ćete logističko Kernel regresijsko strojno učenje kako biste imali referentni model. Nakon toga trenirat ćete klasifikator jezgre kako biste vidjeli možete li postići bolje rezultate.

Koristite sljedeće varijable iz skupa podataka za odrasle:

  • dob
  • radni razred
  • fnlwgt
  • obrazovanje
  • broj_obrazovanja
  • bračni
  • okupacija
  • odnos
  • utrka
  • seks
  • kapitalni dobitak
  • gubitak_kapitala
  • sati_tjedan
  • zavičajna_zemlja
  • označiti

Prije treninga i procjene modela nastavit ćete kako slijedi:

  • Korak 1) Uvezite knjižnice
  • Korak 2) Uvezite podatke
  • Korak 3) Pripremite podatke
  • Korak 4) Konstruirajte input_fn
  • Korak 5) Konstruiranje logističkog modela: osnovni model
  • Korak 6) Procijenite model
  • Korak 7) Napravite klasifikator jezgre
  • Korak 8) Procijenite klasifikator jezgre

Korak 1) Uvezite knjižnice

Da biste uvezli i obučili modele jezgre u umjetnoj inteligenciji, morate uvesti tenzor, pande i numpy

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

Korak 2) Uvezite podatke

Podatke preuzimate sa sljedećeg web mjesta i uvozite ih kao okvir podataka pande.

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

Sada kada su vlak i testni skup definirani, možete promijeniti oznaku stupca iz niza u cijeli broj. tensorflow ne prihvaća vrijednost niza za naljepnicu.

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)

Korak 3) Pripremite podatke

Skup podataka sadrži kontinuirane i kategorijske značajke. Dobra je praksa standardizirati vrijednosti kontinuiranih varijabli. Možete koristiti funkciju StandardScaler iz sci-kit learn. Stvorite i korisnički definiranu funkciju kako biste olakšali pretvorbu vlaka i ispitnog seta. Imajte na umu da kontinuirane i kategorijalne varijable spajate u zajednički skup podataka, a niz bi trebao biti tipa: 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

Funkcija transformatora je spremna, možete pretvoriti skup podataka i stvoriti funkciju 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)

U sljedećem koraku trenirat ćete logističku regresiju. To će vam pružiti točnost osnovne vrijednosti. Cilj je pobijediti osnovnu liniju s drugim algoritmom, naime Kernel klasifikatorom.

Korak 4) Konstruiranje logističkog modela: osnovni model

Stupac značajke konstruirate s objektom real_valued_column. Pobrinut će se da su sve varijable gusti numerički podaci.

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

Procjenitelj se definira pomoću TensorFlow procjenitelja, vi upućujete na stupce značajki i na mjesto spremanja grafa.

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}

Trenirat ćete logisitc regresiju koristeći mini serije veličine 200.

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

Model možete trenirati s 1.000 ponavljanja

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.

Korak 6) Procijenite model

Definirate numpy procjenitelj za procjenu modela. Za procjenu koristite cijeli skup podataka

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

Imate točnost od 82 posto. U sljedećem ćete odjeljku pokušati pobijediti logistički klasifikator klasifikatorom jezgre

Korak 7) Napravite klasifikator jezgre

Procjenitelj jezgre se ne razlikuje toliko od tradicionalnog linearnog klasifikatora, barem u smislu izrade. Ideja je koristiti snagu eksplicitnog jezgra s linearnim klasifikatorom.

Za obuku klasifikatora jezgre potrebna su vam dva unaprijed definirana procjenitelja dostupna u TensorFlowu:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

U prvom ste odjeljku naučili da morate transformirati nisku dimenziju u visoku pomoću funkcije jezgre. Točnije, koristit ćete Random Fouriera, što je aproksimacija Gaussove funkcije. Srećom, Tensorflow u svojoj knjižnici ima funkciju: RandomFourierFeatureMapper. Model se može obučiti pomoću procjenitelja KernelLinearClassifier.

Da biste izgradili model, slijedite ove korake:

  1. Postavite funkciju Kernel visoke dimenzije
  2. Postavite hiperparametar L2
  3. Izgradite model
  4. Obuči model
  5. Procijenite model

Korak A) Postavite funkciju Kernel visoke dimenzije

Trenutni skup podataka sadrži 14 značajki koje ćete transformirati u novu visoku dimenziju 5.000-dimenzionalnog vektora. Služite se slučajnim Fourierovim značajkama za postizanje transformacije. Ako se prisjetite formule Gaussova jezgra, primijetite da postoji parametar standardnog odstupanja koji treba definirati. Ovaj parametar kontrolira mjeru sličnosti koju koristi tijekom klasifikacije.

Sve parametre u RandomFourierFeatureMapper možete podesiti pomoću:

  • ulazni_dim = 14
  • izlazni_dim = 5000
  • stddev = 4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Morate konstruirati mapiranje jezgre pomoću stupaca značajki kreiranih prije: feat_column

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

Korak B) Postavite hiperparametar L2

Da biste spriječili prekomjerno opremanje, kaznite funkciju gubitka pomoću regulatora L2. Hiperparametar L2 postavite na 0,1, a brzinu učenja na 5

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

Korak C) Izradite model

Sljedeći je korak sličan linearnoj klasifikaciji. Koristite ugrađeni procjenitelj KernelLinearClassifier. Imajte na umu da dodate prethodno definirano mapiranje jezgre i promijenite direktorij modela.

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

Korak D) Obučite model

Sad kad je izgrađen klasifikator jezgre, spremni ste ga trenirati. Odlučite se ponoviti 2000 puta više od modela

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

Korak E) Procijenite model

I na kraju, ali ne najmanje važno, ocjenjujete izvedbu svog modela. Trebali biste biti u stanju pobijediti logističku regresiju.

# 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

Konačna točnost je 84%, to je poboljšanje od 2% u odnosu na logističku regresiju. Postoji kompromis između poboljšanja točnosti i računskih troškova. Morate razmisliti vrijedi li poboljšanje od 2% vremena koje različiti klasifikator troši i ima li to uvjerljiv utjecaj na vaše poslovanje.

Sažetak

Kernel je izvrstan alat za transformiranje nelinearnih podataka u (gotovo) linearne. Nedostatak ove metode je računalno dugotrajan i skup.

Ispod možete pronaći najvažniji kôd za obuku klasifikatora jezgre

Postavite funkciju Kernel visoke dimenzije

  • ulazni_dim = 14
  • izlazni_dim = 5000
  • stddev = 4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Postavite hiperparametar L2

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

Izgradite model

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

Obuči model

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

Procijenite model

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