Gaussin ydin koneoppimisessa: Esimerkkejä ytimen menetelmistä

Tämän opetusohjelman tarkoituksena on tehdä tietojoukko lineaarisesti erotettavissa. Opetusohjelma on jaettu kahteen osaan:

1. Ominaisuuden muunnos
2. Kouluta ytimen luokittelija Tensorflow: lla

Ensimmäisessä osassa ymmärrät Kernel-menetelmän idean koneoppimisessa, kun taas toisessa osassa näet, kuinka kouluttaa ytimen luokittelija Tensorflow: lla. Käytät aikuisten tietojoukkoa. Tämän tietojoukon tarkoituksena on luokitella tulot alle 50 000 kk: n tietäen jokaisen kotitalouden käyttäytyminen.

Tässä opetusohjelmassa opit-

• Miksi tarvitset ytimen menetelmiä?
• Mikä on ydin koneoppimisessa?
• Ytimen menetelmien tyypit
• Juna Gaussin ytimen luokittelija TensorFlow: lla

Miksi tarvitset ytimen menetelmiä?

Jokaisen luokittelijan tarkoituksena on ennustaa luokat oikein. Tätä varten tietojoukon tulisi olla erotettavissa. Katso alla oleva juoni; on melko yksinkertaista nähdä, että kaikki mustan viivan yläpuolella olevat pisteet kuuluvat ensimmäiseen luokkaan ja muut pisteet toiseen luokkaan. On kuitenkin erittäin harvinaista, että tietojoukko on niin yksinkertainen. Useimmissa tapauksissa tietoja ei voida erottaa. Kernel-menetelmät koneoppimisessa antavat naiiville luokittelijoille, kuten logistiselle regressiolle, vaikeaa aikaa.

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

Alla olevassa kuvassa piirretään tietoaineisto, joka ei ole lineaarisesti erotettavissa. Jos piirrämme suoran viivan, suurinta osaa pisteistä ei luokitella oikeaan luokkaan.

Yksi tapa puuttua tähän ongelmaan on ottaa datajoukko ja muuttaa tietoja toisella ominaisuuskartalla. Se tarkoittaa, että käytät funktiota muuntamaan tiedot toisessa suunnitelmassa, jonka pitäisi olla lineaarinen.

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

Yllä olevan kuvan tiedot ovat 2D Gaussian -ydinsuunnitelmassa, jota ei voida erottaa. Voit yrittää muuntaa nämä tiedot kolmiulotteisiksi, se tarkoittaa, että luot kuvan, jossa on 3 akselia.

Gaussin ytimen esimerkissämme käytämme polynomikartoitusta tuodaksemme tiedot 3D-ulottuvuuteen. Kaava tietojen muuntamiseksi on seuraava.

Määrität toiminnon Gaussian Kernel Pythonissa uusien ominaisuuskarttojen luomiseksi

Voit koodata yllä olevaa kaavaa numerosarjan avulla:

Kaava	Vastaava Numpy-koodi
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

Uuden kartoituksen tulisi olla 3-ulotteinen ja 16 pistettä

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Tehdään uusi käyrä, jossa on 3 akselia, 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() 

Näemme parannuksen, mutta jos muutamme käyrän suuntaa, on selvää, että tietojoukko on nyt erotettavissa

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

Jos haluat käsitellä suurta tietojoukkoa ja joudut ehkä luomaan enemmän kuin 2 ulottuvuutta, kohtaat suuren ongelman käyttämällä yllä olevaa menetelmää. Itse asiassa sinun on muutettava kaikki datapisteet, mikä ei selvästikään ole kestävää. Se vie ikäsi, ja tietokoneesi muisti voi loppua.

Yleisin tapa ratkaista tämä ongelma on käyttää ydintä .

Mikä on ydin koneoppimisessa?

Ajatuksena on käyttää korkeamman ulottuvuuden ominaisuusaluetta, jotta tiedoista saadaan melkein lineaarisesti erotettavissa, kuten yllä olevassa kuvassa on esitetty.

Datapisteiden erottamiseksi on paljon suurempia ulottuvuuksia. Olemme esimerkiksi osoittaneet, että polynomikartoitus on hyvä alku.

Olemme myös osoittaneet, että paljon tietoja käytettäessä nämä muunnokset eivät ole tehokkaita. Sen sijaan voit käyttää koneoppimisen ytintoimintoa tietojen muokkaamiseen muuttamatta uuteen ominaisuusohjelmaan.

Ytimen taika on löytää toiminto, joka välttää kaikki ongelmat, joihin korkea-ulotteinen laskenta merkitsee. Ytimen tulos on skalaari, tai toisin sanoen olemme palanneet yksiulotteiseen avaruuteen

Kun olet löytänyt tämän toiminnon, voit liittää sen tavalliseen lineaariseen luokittelijaan.

Katsotaanpa esimerkki ytimen koneoppimisen käsitteen ymmärtämiseksi. Sinulla on kaksi vektoria, x1 ja x2. Tavoitteena on luoda korkeampi ulottuvuus käyttämällä polynomikartoitusta. Tulos on yhtä suuri kuin uuden ominaisuuskartan pistetulo. Yllä olevasta menetelmästä joudut:

1. Muunna x1 ja x2 uudeksi ulottuvuudeksi
2. Laske pistetulo: yhteinen kaikille ytimille
3. Muunna x1 ja x2 uudeksi ulottuvuudeksi

Voit käyttää yllä luotua toimintoa korkeamman ulottuvuuden laskemiseen.

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

Tuotos

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

Laske pistetulo

Voit käyttää numpy-objektipistettä laskeaksesi pistetulon ensimmäisen ja toisen vektoriin x_1 tallennetun vektorin välillä.

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

Lähtö on 8100. Näet ongelman, sinun on tallennettava muistiin uusi ominaisuuskartta pistetuotteen laskemiseksi. Jos sinulla on tietojoukko, jossa on miljoonia tietueita, se on laskennallisesti tehoton.

Sen sijaan voit käyttää polynomin ydintä pistetulon laskemiseen muuntamatta vektoria. Tämä toiminto laskee x1: n ja x2: n pistetulon ikään kuin nämä kaksi vektoria olisi muunnettu korkeampaan ulottuvuuteen. Toisin sanoen ytintoiminto laskee pistetuotteen tulokset toisesta ominaisuusavaruudesta.

Voit kirjoittaa polynomisen ytimen funktion Pythonissa seuraavasti.

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

Se on kahden vektorin pistetulon voima. Alla palautat polynomisen ytimen toisen asteen. Lähtö on yhtä suuri kuin toinen menetelmä. Tämä on ytimen taika.

polynomial_kernel(x1, x2, p=2)8100 

Ytimen menetelmien tyypit

Saatavilla on paljon erilaisia ​​ytintekniikoita. Yksinkertaisin on lineaarinen ydin. Tämä toiminto toimii melko hyvin tekstiluokituksessa. Toinen ydin on:

• Polynominen ydin
• Gaussin ydin

TensorFlow-esimerkissä käytämme Random Fourieria. TensorFlow: lla on sisäänrakennettu estimaattori uuden ominaisuusalueen laskemiseksi. Gaussin suodatintoiminto on likiarvo Gaussin ytintoiminnosta.

Gaussin suodatustoiminto laskee datapisteiden samankaltaisuuden paljon korkeammassa ulottuvuudessa.

Juna Gaussin ytimen luokittelija TensorFlow: lla

Algoritmin tavoitteena on luokitella kotitalous, joka ansaitsee enemmän tai vähemmän kuin 50k.

Arvioit logistisen ytimen regressio-koneoppimisen vertailumallin saamiseksi. Sen jälkeen koulutat ytimen luokittelijan selvittämään, voitko saada parempia tuloksia.

Käytät seuraavia muuttujia aikuisten tietojoukosta:

• ikä
• työluokka
• fnlwgt
• koulutus
• koulutus_num
• avioliitto
• ammatti
• suhde
• rotu
• sukupuoli
• myyntivoitto
• pääoman menetys
• tuntia viikkoa
• Kotimaa
• etiketti

Suoritat seuraavalla tavalla ennen kuin harjoittelet ja arvioit mallia:

• Vaihe 1) Tuo kirjastot
• Vaihe 2) Tuo tiedot
• Vaihe 3) Valmistele tiedot
• Vaihe 4) Rakenna input_fn
• Vaihe 5) Rakenna logistinen malli: perusmalli
• Vaihe 6) Arvioi malli
• Vaihe 7) Rakenna ytimen luokittelija
• Vaihe 8) Arvioi ytimen luokittelija

Vaihe 1) Tuo kirjastot

Jos haluat tuoda ja kouluttaa ytimen malleja tekoälyssä, sinun on tuotava tensorflow, pandat ja numpy

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

Vaihe 2) Tuo tiedot

Lataat tiedot seuraavalta verkkosivustolta ja tuot ne pandatietokehyksenä.

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

Nyt kun juna ja testijoukko on määritelty, voit vaihtaa sarakeotsikon merkkijonosta kokonaislukuun. tensorflow ei hyväksy merkkijonoarvoa.

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)

Vaihe 3) Valmistele tiedot

Aineisto sisältää sekä jatkuvia että kategorisia ominaisuuksia. Hyvä käytäntö on yhtenäistää muuttujien arvot. Voit käyttää sci-kit-oppimisen toimintoa StandardScaler. Luot myös käyttäjän määrittelemän toiminnon helpottaaksesi junan ja testisarjan muuntamista. Huomaa, että yhdistät jatkuvat ja kategoriset muuttujat yhteiseksi tietojoukoksi ja taulukon tulisi olla tyyppiä: 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 

Muuntajatoiminto on valmis, voit muuntaa tietoaineiston ja luoda input_fn-toiminnon.

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

Seuraavassa vaiheessa harjoitat logistista regressiota. Se antaa sinulle perustason tarkkuuden. Tavoitteena on voittaa perustaso toisella algoritmilla, nimittäin ytimen luokittelijalla.

Vaihe 4) Rakenna logistinen malli: perusmalli

Rakennat ominaisuussarakkeen objektilla real_valued_column. Se varmistaa, että kaikki muuttujat ovat tiheitä numeerisia tietoja.

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

Estimaattori määritetään käyttämällä TensorFlow Estimator -ohjelmaa, ohjeet ominaisuussarakkeet ja mihin kaavio tallennetaan.

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} 

Harjoittelet logisitc-regressiota käyttämällä kokoa 200 olevia minieriä.

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

Voit kouluttaa mallia 1000 toistolla

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.

Vaihe 6) Arvioi malli

Määrittelet numpy-estimaattorin mallin arvioimiseksi. Käytät koko tietojoukkoa arviointiin

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

Sinulla on 82 prosentin tarkkuus. Seuraavassa osassa yrität voittaa logistisen luokittelijan ytimen luokittelijalla

Vaihe 7) Rakenna ytimen luokittelija

Ytimen estimaattori ei ole niin rakenteeltaan niin erilainen kuin perinteinen lineaarinen luokittelija. Ajatuksena on käyttää eksplisiittisen ytimen voimaa lineaarisen luokittelijan kanssa.

Tarvitset kaksi ennalta määritettyä estimaattoria, jotka ovat käytettävissä TensorFlow-sovelluksessa ytimen luokittelijan kouluttamiseksi:

• RandomFourierFeatureMapper
• YtimenLineaarinen luokittelija

Opit ensimmäisessä osassa, että sinun on muutettava matala ulottuvuus korkeaksi ulottuvuudeksi ytintoiminnon avulla. Tarkemmin sanottuna käytät Random Fourieria, joka on likiarvo Gaussin funktiosta. Onneksi Tensorflow-kirjastossa on toiminto: RandomFourierFeatureMapper. Mallia voidaan kouluttaa estimaattorilla KernelLinearClassifier.

Rakenna malli noudattamalla näitä vaiheita:

1. Aseta korkean ulottuvuuden ytimen toiminto
2. Aseta L2-hyperparametri
3. Rakenna malli
4. Harjoittele mallia
5. Arvioi malli

Vaihe A) Aseta korkean ulottuvuuden ytimen toiminto

Nykyinen tietojoukko sisältää 14 ominaisuutta, jotka muunnat uudeksi 5.000-ulotteisen vektorin suureksi ulottuvuudeksi. Muunnoksen aikaansaamiseksi käytetään satunnaisia ​​Fourier-ominaisuuksia. Jos muistat Gaussin ytimen kaavan, huomaat, että on määritettävä standardipoikkeaman parametri. Tämän parametrin säätimet samankaltaisuuden mittaamiseksi käytetään luokituksen aikana.

Voit virittää kaikki RandomFourierFeatureMapperin parametrit seuraavilla tavoilla:

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

Sinun on rakennettava ytimen kartoitin käyttämällä aiemmin luotuja ominaisuussarakkeita: feat_column

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

Vaihe B) Aseta L2-hyperparametri

Yliasennuksen estämiseksi rangaistaan ​​häviötoiminto L2-säätimellä. Asetat L2-hyperparametrin arvoksi 0,1 ja oppimisnopeudeksi 5

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

Vaihe C) Rakenna malli

Seuraava vaihe on samanlainen kuin lineaarinen luokittelu. Käytät sisäänrakennettua estimaattoria KernelLinearClassifier. Huomaa, että lisäät aiemmin määritetyn ytimen kartoittimen ja muutat mallihakemistoa.

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

Vaihe D) Harjoittele mallia

Nyt kun ytimen luokittelija on rakennettu, olet valmis kouluttamaan sitä. Voit toistaa mallia 2000 kertaa

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

Vaihe E) Arvioi malli

Viimeisenä mutta ei vähäisimpänä, arvioit mallisi suorituskyvyn. Sinun pitäisi pystyä voittamaan logistinen regressio.

# 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

Lopullinen tarkkuus on 84%, se on 2% parannus verrattuna logistiseen regressioon. Tarkkuuden parantamisen ja laskennallisten kustannusten välillä on kompromissi. Sinun täytyy miettiä, onko kahden prosentin parannus eri luokittelijan kuluttaman ajan arvoinen ja onko sillä pakottava vaikutus yritykseesi.

Yhteenveto

Ydin on loistava työkalu muuntaa epälineaarinen data (melkein) lineaariseksi. Tämän menetelmän puute on se, että se on laskennallisesti aikaa vievää ja kallista.

Alla on tärkein koodi ytimen luokittelijan kouluttamiseksi

Aseta korkean ulottuvuuden ytimen toiminto

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

Aseta L2-hyperparametri

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

Rakenna malli

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

Harjoittele mallia

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

Arvioi malli

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