Gaussin ydin koneoppimisessa: Python Ytimen menetelmät

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

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

Ensimmäisessä osassa ymmärrät koneoppimisen ydinmenetelmän idean, kun taas toisessa osassa näet kuinka ytimen luokittelija koulutetaan Tensorflow:n avulla. Käytät aikuisten tietojoukkoa. Tämän tietojoukon tavoitteena on luokitella tulot alle ja yli 50 XNUMX kunkin kotitalouden käyttäytymisen perusteella.

Miksi tarvitset ydinmenetelmiä?

Jokaisen luokittelijan tavoitteena on ennustaa luokat oikein. Tätä varten tietojoukon tulee 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 näin yksinkertainen. Useimmissa tapauksissa tiedot eivät ole erotettavissa. Koneoppimisen ydinmenetelmät vaikeuttavat naiivia luokittelua, kuten logistista regressiota.

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

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

Yksi tapa ratkaista tämä ongelma on ottaa tietojoukko ja muuntaa tiedot toiseen ominaisuuskarttaan. Se tarkoittaa, että käytät funktiota tietojen muuntamiseen toiseen suunnitelmaan, 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 Gaussin ydinsuunnitelmassa, jota ei voi erottaa. Voit yrittää muuttaa nämä tiedot kolmiulotteiseksi, se tarkoittaa, että luot hahmon, jossa on 3 akselia.

Gaussin ytimen esimerkissämme käytämme polynomikartoitusta tuodaksemme tietomme kolmiulotteiseen ulottuvuuteen. Kaava tietojen muuntamiseksi on seuraava.

Voit määrittää funktion Gaussin ytimessä Python luodaksesi uusia karttakohteita

Voit käyttää numpy koodataksesi yllä olevan kaavan:

Kaava	Vastaava Numpy-koodi
x	x[:,0]**
y	x[:,1]
x2	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y2	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			

Uuden kartoituksen tulee olla 3-ulotteinen ja 16 pistettä

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Tehdään uusi kuvaaja, jossa on 3 akselia, x, y ja z, vastaavasti.

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

Näemme parannusta, mutta jos muutamme kaavion suuntaa, on selvää, että tietojoukko on nyt erotettavissa

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

Jos haluat käsitellä suurta tietojoukkoa ja joutua luomaan enemmän kuin kaksi 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 iät, ja tietokoneesi muisti saattaa loppua.

Yleisin tapa ratkaista tämä ongelma on käyttää a ydin.

Mikä on ydin koneoppimisessa?

Ajatuksena on käyttää korkeamman ulottuvuuden piirreavaruutta, jotta data olisi lähes lineaarisesti erotettavissa yllä olevan kuvan mukaisesti.

On paljon korkeamman ulottuvuuden tiloja, jotta datapisteet voidaan erottaa. Olemme esimerkiksi osoittaneet, että polynomikartoitus on loistava alku.

Olemme myös osoittaneet, että suurella datalla nämä muunnokset eivät ole tehokkaita. Sen sijaan voit käyttää Machine Learningin ydintoimintoa muokataksesi tietoja vaihtamatta uuteen ominaisuussuunnitelmaan.

Ytimen taika on löytää funktio, joka välttää kaikki korkeaulotteisen laskennan aiheuttamat ongelmat. Ytimen tulos on skalaari tai toisin sanoen olemme palanneet yksiulotteiseen avaruuteen

Kun olet löytänyt tämän funktion, voit liittää sen tavalliseen lineaariluokittimeen.

Katsotaanpa esimerkkiä ytimen koneoppimisen käsitteen ymmärtämiseksi. Sinulla on kaksi vektoria, x1 ja x2. Tavoitteena on luoda korkeampi ulottuvuus polynomikartoituksen avulla. Tulos on yhtä suuri kuin uuden piirrekartan pistetulo. Yllä olevasta menetelmästä sinun tulee:

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 funktiota korkeamman ulottuvuuden laskemiseen.

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

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

ulostulo

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

Laske pistetulo

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

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

Tulos on 8100. Näet ongelman, sinun on tallennettava muistiin uusi ominaisuuskartta pistetulon laskemiseksi. Jos sinulla on miljoonia tietueita sisältävä tietojoukko, se on laskennallisesti tehoton.

Sen sijaan voit käyttää polynomiydin pistetulon laskemiseksi muuntamatta vektoria. Tämä funktio laskee x1:n ja x2:n pistetulon ikään kuin nämä kaksi vektoria olisi muunnettu korkeampaan ulottuvuuteen. Toisin sanottuna ydinfunktio laskee pistetulon tulokset toisesta ominaisuusavaruudesta.

Voit kirjoittaa polynomiytimen funktion sisään Python seuraavasti.

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

Se on kahden vektorin pistetulon teho. Alla palautat polynomiytimen toisen asteen. Tulos on sama kuin toisella menetelmällä. Tämä on ytimen taika.

polynomial_kernel(x1, x2, p=2)			
8100

Ydinmenetelmien tyypit

Käytettävissä on paljon erilaisia ​​ydintekniikoita. Yksinkertaisin on lineaarinen ydin. Tämä toiminto toimii melko hyvin tekstin luokittelussa. Toinen ydin on:

• Polynominen ydin
• Gaussin ydin

Esimerkissä kanssa TensorFlow, käytämme satunnaista Fourieria. TensorFlow'ssa on sisäänrakennettu estimaattori uuden ominaisuustilan laskemiseksi. Gaussin suodatinfunktio on Gaussin ydinfunktion likiarvo.

Gaussin suodatusfunktio laskee datapisteiden samankaltaisuuden paljon korkeammassa ulottuvuudessa.

Harjoittele Gaussian Kernel -luokittaja TensorFlow'lla

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

Arvioit logistisen ytimen regressiokoneoppimisen benchmark-mallin saamiseksi. Sen jälkeen harjoittelet ytimen luokittelijaa nähdäksesi, voitko saada parempia tuloksia.

Käytät seuraavia muuttujia aikuisten tietojoukosta:

• ikä
• työluokka
• fnlwgt
• koulutus
• koulutus_nm
• avio-
• ammatti
• yhteys
• rotu
• sukupuoli
• myyntivoitto
• pääoma_tappio
• tuntia_viikko
• Kotimaa
• etiketti

Toimi seuraavasti, ennen kuin harjoittelet ja arvioit mallia:

• Vaihe 1) Tuo kirjastot
• Vaihe 2) Tuo tiedot
• Vaihe 3) Valmistele tiedot
• Vaihe 4) Muodosta input_fn
• Vaihe 5) Rakenna logistinen malli: Perusmalli
• Vaihe 6) Arvioi malli
• Vaihe 7) Luo ytimen luokitin
• Vaihe 8) Arvioi ytimen luokitin

Vaihe 1) Tuo kirjastot

Tuoda ja kouluttaa ydinmalleja Tekoäly, sinun on tuotava tensorflow, pandas ja nuhjuinen

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Vaihe 2) Tuo tiedot

Lataat tiedot seuraavista verkkosivusto ja tuot sen panda-tietokehyksenä.

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

Nyt kun juna- ja testijoukko on määritetty, voit muuttaa sarakkeen otsikon merkkijonosta kokonaisluvuksi. 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 standardisoida jatkuvien muuttujien arvot. Voit käyttää toimintoa StandardScaler sci-kit learningistä. Luot myös käyttäjän määrittämän funktion, joka helpottaa junan ja testijoukon muuntamista. Huomaa, että ketjutat jatkuvat ja kategoriset muuttujat yhteiseen tietojoukkoon ja taulukon tulee 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 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

Muuntajatoiminto on valmis, voit muuntaa tietojoukon ja luoda input_fn-funktion.

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 harjoittelet logistista regressiota. Se antaa sinulle perustason tarkkuuden. Tavoitteena on voittaa perusviiva eri algoritmilla, nimittäin ytimen luokittimella.

Vaihe 4) Rakenna logistinen malli: Perusmalli

Rakennat ominaisuussarakkeen objektilla real_valued_column. Se varmistaa, että kaikki muuttujat ovat tiheää numeerista dataa.

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

Estimaattori määritellään TensorFlow Estimatorilla, ohjeistat 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': <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}

Harjoittelet logistista regressiota käyttämällä 200-kokoisia minieriä.

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

Voit harjoitella mallia 1.000 XNUMX iteraatiolla

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>

Vaihe 6) Arvioi malli

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

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

Sinulla on 82 prosentin tarkkuus. Seuraavassa osiossa yrität päihittää logistisen luokittelijan ytimen luokittimella

Vaihe 7) Muodosta ytimen luokitin

Ytimen estimaattori ei ainakaan rakenteeltaan eroa niin paljon perinteisestä lineaarisesta luokittimesta. Ideana on käyttää eksplisiittisen ytimen voimaa lineaarisen luokittelijan kanssa.

Tarvitset kaksi ennalta määritettyä estimaattoria, jotka ovat saatavilla TensorFlow'ssa ytimen luokittelijan kouluttamiseen:

• RandomFourier FeatureMapper
• KernelLinearClassifier

Opit ensimmäisessä osiossa, että sinun on muutettava alhainen ulottuvuus korkeaksi mittasuhteeksi ydinfunktion avulla. Tarkemmin sanottuna käytät satunnaista Fourieria, joka on Gaussin funktion likiarvo. Onneksi Tensorflown kirjastossa on toiminto: RandomFourierFeatureMapper. Mallia voidaan kouluttaa käyttämällä estimaattoria KernelLinearClassifier.

Rakentaaksesi mallin, toimi seuraavasti:

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

Vaihe A) Aseta korkean ulottuvuuden ydintoiminto

Nykyinen tietojoukko sisältää 14 ominaisuutta, jotka muunnat 5.000 XNUMX-ulotteisen vektorin uudeksi korkeaksi ulottuvuudeksi. Käytät satunnaisia ​​Fourier-ominaisuuksia muunnoksen saavuttamiseen. Jos muistat Gaussin ytimen kaavan, huomaat, että on määritettävä standardipoikkeamaparametri. Tämä parametri ohjaa luokituksen aikana käytettävää samankaltaisuusmittausta.

Voit virittää kaikki RandomFourierFeatureMapperin parametrit seuraavilla tavoilla:

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

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

### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

Vaihe B) Aseta L2-hyperparametri

Liiallisen sovituksen estämiseksi rankaise häviötoimintoa L2-regulaattorilla. Asetat L2-hyperparametriksi 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ääritellyn ytimen kartoittajan ja muutat mallihakemistoa.

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

Vaihe D) Harjoittele mallia

Nyt kun ytimen luokitin on rakennettu, olet valmis kouluttamaan sitä. Valitset mallin toistamisen 2000 kertaa

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

Vaihe E) Arvioi malli

Viimeisenä mutta ei vähäisimpänä, arvioit mallisi suorituskykyä. 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 <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

Lopullinen tarkkuus on 84 %, se on 2 % parannus logistiseen regressioon verrattuna. Tarkkuuden parantamisen ja laskentakustannusten välillä on kompromissi. Sinun on mietittävä, onko 2 %:n parannus eri luokittelijan käyttämän ajan arvoista ja onko sillä vakuuttava vaikutus liiketoimintaasi.

Yhteenveto

Ydin on loistava työkalu muuntaa epälineaarista dataa (melkein) lineaariseksi. Tämän menetelmän puute on laskennallisesti aikaa vievä ja kallis.

Alta löydät tärkeimmän koodin ytimen luokittelijan kouluttamiseen

Aseta korkean ulottuvuuden ydintoiminto

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