Gaussin ydin koneoppimisessa: Python Ytimen menetelmät

⚡ Älykäs yhteenveto

Gaussin ydinmenetelmät tekevät erotettavissa olevasta datasta lineaarisesti erotettavissa ilman, että koskaan tarvitsee rakentaa korkeaulotteista ominaisuuskarttaa. Tämä läpikäynti näyttää polynomikartan.ping käsin ja kouluttaa sitten satunnaisen Fourier-ydinluokittelijan TensorFlow'ssa.

  • 🔘 Erotettavuuden ongelma: Lineaariset luokittelijat epäonnistuvat, jos mikään suora viiva ei jaa luokkia alkuperäisessä ominaisuusavaruudessa.
  • ☑️ Polynomikarttaping: Muunnos x:n neliöksi, kahden juuri xy:ksi ja y:n neliöksi nostaa kaksi ulottuvuutta kolmeksi ja erottelee näytedatan.
  • ✅ Ytimen temppu: Ydin palauttaa kartoitettujen vektorien pistetulon suoraan, joten laajennettua ominaisuuskarttaa ei koskaan tallenneta.
  • 🧪 Kolme ydintä: Lineaarinen sopii tekstin luokitteluun, polynomi tallentaa ominaisuuksien vuorovaikutukset ja Gaussinen RBF mittaa etäisyyteen perustuvaa samankaltaisuutta.
  • 🛠️ TensorFlow-koontiversio: RandomFourierFeatureMapper projisoi 14 ominaisuutta 5 000 ulottuvuuteen ennen kuin KernelLinearClassifier harjoittelee Ftrl-optimoijalla.
  • 📈 Mitattu tulos: Ytimen luokittelijan tarkkuus on 0.83975184, kun taas logistisen perustason tarkkuus on 0.82353663.

Gaussin ydin koneoppimisessa

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

  1. Ominaisuuden muunnos
  2. Ytimen luokittelijan kouluttaminen TensorFlow'lla

Ensimmäisessä osassa ymmärrät koneoppimisen ydinmetodin taustalla olevan idean, kun taas toisessa osassa näet, miten ydinluokittelijaa koulutetaan TensorFlowKäytät aikuisille tarkoitettua tietojoukkoa. Tämän tietojoukon tavoitteena on luokitella alle ja yli 50 000 euron tulot tietäen kunkin kotitalouden käyttäytymisen.

Miksi tarvitset ydinmenetelmiä?

Jokaisen luokittelijan tavoitteena on ennustaa luokat oikein. Tätä varten datajoukon tulisi olla erotettavissa. Katso alla olevaa kuvaajaa; 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ä datajoukko on näin yksinkertainen. Useimmissa tapauksissa data ei ole erotettavissa, ja erotettavissa oleva data vaikeuttaa naiivien luokittelijoiden, kuten logistisen regression, toimintaa.

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

Lineaarisesti erotettavissa olevan tietojoukon sirontakaavio, joka on jaettu siististi suoralla mustalla viivalla

Alla olevassa kuvassa piirrämme aineiston, joka ei ole lineaarisesti separoituva. Jos piirrämme suoran viivan, useimmat pisteet eivät luokitella oikeaan luokkaan.

Yksi tapa ratkaista tämä ongelma on muuntaa datajoukko toiseksi ominaisuuskartaksi. Tämä tarkoittaa, että käytät funktiota siirtääksesi datan toiseen tasoon, jonka pitäisi olla lineaarisesti separoituva.

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

Hajontakaavio tietojoukosta, jossa kaksi luokkaa ovat päällekkäin eikä niiden välillä ole suoraa viivaa

Yllä olevan kuvan tiedot sijaitsevat kaksiulotteisessa tasossa, eikä niitä voida erottaa toisistaan. Voit yrittää muuntaa tiedot kolmiulotteisiksi, eli luoda kuvan, jossa on kolme akselia.

Gaussin ytimen esimerkissämme käytämme polynomikarttaaping tuodaksemme datamme kolmanteen ulottuvuuteen. Datan muuntamiskaava on seuraava.

Polynomikarttaping kaava x:n ja y:n phi on x:n neliö, neliöjuuri kahdesta kerrottuna xy:llä, y:n neliö

Voit määrittää funktion Gaussin ytimessä Python uusien ominaisuuskarttojen luomiseksi.

Voit käyttää nuhjuinen koodata yllä oleva kaava. Jokainen alla oleva rivi yhdistää yhden kartan terminping taulukkolausekkeella, joka sen tuottaa, ja pieni kuva merkitsee kahden tekijän neliöjuurta.

Kaava Vastaava NumPy-koodi
x x[:,0]
y x[:,1]
x² x[:,0]**2
Kahden tekijän neliöjuuri polynomikartastaping 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			

Uusi karttaping siinä on 3 ulottuvuutta ja 16 pistettä.

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

Piirrä nyt uusi kuvaaja, jossa on kolme akselia, x, y ja z.

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

Kolmiulotteinen hajontakaavio kartoitetuista pisteistä 30 asteen korkeudesta ja 185 asteen atsimuutista katsottuna

Näemme parannusta, mutta jos muutamme kuvaajan suuntaa, käy selväksi, 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()

Sama kolmiulotteinen kuvaaja kierrettynä tasaiseksi, jossa yksi taso jakaa kaksi luokkaa

Jos joudut käsittelemään suurta tietojoukkoa ja luomaan yli kaksi ulottuvuutta, kohtaat yllä olevan menetelmän kanssa suuren ongelman. Itse asiassa sinun on muunnettava kaikki datapisteet, mikä ei selvästikään ole kestävää. Se vie ikuisuuden, ja tietokoneesi muisti saattaa loppua kesken.

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

Mikä on ydin koneoppimisessa?

Ajatuksena on käyttää korkeamman ulottuvuuden ominaisuusavaruutta, jotta datasta tulisi lähes lineaarisesti erotettavissa, kuten yllä olevassa kuvassa on esitetty.

On paljon korkeamman ulottuvuuden avaruuksia, jotka tekevät datapisteistä erotettavissa olevia. Olemme esimerkiksi osoittaneet, että polynomikuvausping on loistava aloitus.

Olemme myös osoittaneet, että suurten datamäärien kanssa nämä muunnokset eivät ole tehokkaita. Sen sijaan voit käyttää koneoppimisen ydinfunktiota datan muokkaamiseen siirtymättä uuteen ominaisuustasoon.

Ytimen taika on löytää funktio, joka välttää kaikki moniulotteisen laskennan aiheuttamat ongelmat. Ytimen tulos on skalaari, tai toisin sanoen olemme takaisin yksiulotteisessa avaruudessa.

Kun olet löytänyt tämän funktion, voit kytkeä sen standardiin lineaariseen luokittelijaan.

Tässä on esimerkki, joka tekee ydinkoneoppimisen käsitteen konkreettiseksi. Sinulla on kaksi vektoria, x1 ja x2. Tavoitteena on luoda korkeampi ulottuvuus käyttämällä polynomikuvausta.pingTuloste on yhtä suuri kuin uuden ominaisuuskartan pistetulo. Yllä olevasta menetelmästä sinun on tehtävä seuraava:

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

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ä kohdasta nuhjuinen laskeakseen x_1:een tallennetun ensimmäisen ja toisen vektorin pistetulon.

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

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

Sen sijaan voit käyttää polynomiydintä pistetulon laskemiseen vektoria muuntamatta. Tämä funktio laskee x1:n ja x2:n pistetulon ikään kuin nämä kaksi vektoria olisi muunnettu korkeampaan ulottuvuuteen. Toisin sanoen ydinfunktio laskee pistetulon tuloksen 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 monia erilaisia ​​ydintekniikoita. Yksinkertaisin on lineaarinen ydin. Tämä funktio toimii melko hyvin tekstin luokitteluun. Muut ytimet ovat:

  • Polynominen ydin
  • Gaussin ydin

Alla oleva taulukko yhteenvetää, mitä kukin tekee ja milloin ammattilaiset tarttuvat siihen.

Ydin Mitä se laskee Tyypillinen käyttö
Lineaarinen Alkuperäisen piirreavaruuden yksinkertainen pistetulo Jo erotettavissa oleva data ja korkeaulotteiset tekstiominaisuudet
polynomi Pistetulo korotettuna asteeseen p, mikä kuvaa ominaisuuksien vuorovaikutuksia Kaarevat rajat, kun vuorovaikutusten tiedetään olevan tärkeitä
Gaussin jakauma (RBF) Etäisyyteen perustuva samankaltaisuus, joka lähestyy nollaa pisteiden liikkuessa erilleen Tavallinen ensimmäinen valinta, kun reunan muoto on tuntematon

TensorFlow-esimerkissä käytämme satunnaisia ​​Fourier-piirteitä. TensorFlow'ssa on sisäänrakennettu estimaattori uuden ominaisuusavaruuden laskemiseksi. Satunnainen Fourier-piirteiden kartoittaja on approksimaatio alla olevasta Gaussin ydinfunktiosta.

Gaussin ydinkaava: e korotettuna miinus x:n neliönormi miinus y jaettuna kahdella sigma-neliöllä

Gaussin suodatusfunktio laskee datapisteiden samankaltaisuuden paljon korkeammassa ulottuvuudessa.

Teorian selvitettyä loppuosan tässä läpikäynnissä Gaussinen ydin hyödynnetään todellisessa tietojoukossa.

Harjoittele Gaussian Kernel -luokittaja TensorFlow'lla

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

Ensin arvioit logistista regressiota saadaksesi vertailumallin. Sen jälkeen koulutat ytimen luokittelijan 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 mallin kouluttamista ja arviointia:

  1. Tuo kirjastot
  2. Tuo tiedot
  3. Valmistele tiedot
  4. Logistisen mallin luominen: perusmalli
  5. Arvioi malli
  6. Ytimen luokittelijan rakentaminen ja arviointi

Versiohuomautus: Jokainen alla oleva koodinpätkä kohdistuu TensorFlow 1.x:ään. tf.contrib-nimiavaruus, joka tarjoaa real_valued_columnin, RandomFourierFeatureMapperin ja KernelLinearClassifierin, poistettiin TensorFlow 2.0:ssa, ja itse tf.estimator poistettiin TensorFlow 2.16:ssa. Nykyisessä versiossa sama putki rakennetaan tf.keras.layers.experimental.RandomFourierFeatures-kerroksella, jota seuraa Dense-tuloskerros, tai scikit-learnin RBFSampler- ja SGDClassifier-parilla.

Vaihe 1) Tuo kirjastot

Tuoda ja kouluttaa ydinmalleja Tekoäly, sinun on tuotava TensorFlow, pandas ja NumPy.

#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 osoitteesta UCI:n aikuisille suunnattu tietokantasivu ja tuo se pandas DataFrame -muodossa.

## 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ääritelty, voit muuttaa sarakkeen otsikon merkkijonosta kokonaisluvuksi. TensorFlow ei hyväksy merkkijonoarvoja otsikolle.

label = {&#x27;<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {&#x27;<=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 standardoida jatkuvien muuttujien arvot. Voit käyttää StandardScaler-funktiota kohdasta scikit opittavaLuot myös käyttäjän määrittämän funktion helpottaaksesi juna- ja testijoukon muuntamista. Huomaa, että yhdistät jatkuvat ja kategoriset muuttujat yhteiseksi tietojoukoksi ja taulukon tulee olla tyyppiä float32.

COLUMNS_INT = [&#x27;age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']
CATE_FEATURES = [&#x27;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[&#x27;label'].astype(np.int32)    
    X_conc = np.c_[df_scaled, X_1].astype(np.float32)				
    return X_conc, y

Transformer-funktio on valmis, joten voit muuntaa datajoukon 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(&#x27;features', dimension=14)

Estimaattori määritellään TensorFlow Estimator API:n avulla; annat ominaisuussarakkeet ja graafin tallennuspaikan.

estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],
                                          n_classes=2,
                                          model_dir = "kernel_log"
                                         )	
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {&#x27;_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}

Koulutat logistista regressiota käyttämällä 200 kappaleen kokoisia mini-eriä.

# 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 kouluttaa mallia 1 000 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 5) Arvioi malli

Määrittelet NumPy-syötefunktion mallin arvioimiseksi. Käytät koko testijoukkoa 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
{&#x27;accuracy': 0.82353663,
 &#x27;accuracy_baseline': 0.76377374,
 &#x27;auc': 0.84898686,
 &#x27;auc_precision_recall': 0.67214864,
 &#x27;average_loss': 0.3877216,
 &#x27;global_step': 1000,
 &#x27;label/mean': 0.23622628,
 &#x27;loss': 6312.495,
 &#x27;precision': 0.7362797,
 &#x27;prediction/mean': 0.21208474,
 &#x27;recall': 0.39417577}

Tarkkuutesi on 82 prosenttia. Seuraavassa osiossa yrität päihittää logistisen luokittelijan ydinluokittelijalla.

Vaihe 6) Luo ytimen luokitin

Ytimen estimaattori ei ole kovin erilainen kuin perinteinen lineaarinen luokittelija, ainakaan rakenteensa puolesta. Sen taustalla oleva ajatus on yhdistää eksplisiittisen ydinkuvauksen tehoping lineaarisen luokittelijan kanssa.

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

  • RandomFourier FeatureMapper
  • KernelLinearClassifier

Ensimmäisessä osiossa opit, että sinun on muunnettava matala ulottuvuus korkeaksi ulottuvuudeksi käyttämällä ydinfunktiota. Tarkemmin sanottuna käytät satunnaisia ​​Fourier-piirteitä, jotka approksimoivat Gaussin funktiota. TensorFlow 1.x tarjoaa kyseisen kuvauksen.ping kuten RandomFourierFeatureMapper, ja mallia voidaan kouluttaa estimaattorilla 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 ydinfunktio

Nykyinen aineisto sisältää 14 ominaisuutta, jotka muunnat uudeksi 5 000-ulotteiseksi vektoriksi. Muunnos tehdään satunnaisten Fourier-ominaisuuksien avulla. Jos muistat Gaussin ytimen kaavan, huomaat, että on määriteltävä keskihajontaparametri. Tämä parametri ohjaa luokittelussa käytettyä samankaltaisuusmittaa: pieni keskihajonta saa ytimen käsittelemään vain hyvin lähellä olevia pisteitä samankaltaisina, kun taas suuri tasoittaa päätösrajaa.

Voit virittää kaikki RandomFourierFeatureMapperin parametrit seuraavilla tavoilla:

  • input_dim = 14
  • lähtö_himmennys = 5000
  • keskihajonta = 4
### Prep Kernel
kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name=&#x27;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

Ylisovituksen estämiseksi rankaiset häviöfunktiota L2-regularisoijalla. Asetat L2-hyperparametrin arvoon 0.1 ja oppimisnopeuden arvoon 5.

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

Vaihe C) Mallin rakentaminen

Seuraava vaihe on samanlainen kuin lineaarisessa luokittelussa. Käytät sisäänrakennettua estimaattoria KernelLinearClassifieria. Huomaa, että lisäät aiemmin määritellyn ytimen mapperin 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")

Alla olevat vanhentumisvaroitukset ovat odotettavissa TensorFlow 1.x:ssä, koska kernel_methods-moduuli on rakennettu vanhempien tf.contrib.learn-estimaattoreiden päälle.

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: {&#x27;_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
}
, &#x27;_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) Mallin kouluttaminen

Nyt kun ydinluokittelija on rakennettu, olet valmis kouluttamaan sitä. Valitset mallin iterointikerran 2 000 kertaa.

### estimate 
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting <dtype: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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={&#x27;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) Mallin arviointi

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: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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 %, noin 1.6 prosenttiyksikköä logistisen regression perustasoa (0.83975184 vs. 0.82353663) korkeampi. Tarkkuuden parantumisen ja laskentakustannusten välillä on kompromissi. Sinun on mietittävä, onko parannus raskaamman luokittelijan käyttämän ajan arvoinen ja onko sillä vakuuttava vaikutus liiketoimintaasi.

UKK

Ytimen temppu laskee kahden vektorin pistetulon korkeaulotteisen kuvauksen jälkeenping, ilman että koskaan rakentaisi sitä karttaapingTämän opetusohjelman polynomial_kernel-funktio palauttaa suoraan arvon 8100, joka on sama kuin eksplisiittinen kolmiulotteinen muunnos.

Ei. tf.contrib poistettiin TensorFlow 2.0:ssa ja tf.estimator versiossa 2.16, joten real_valued_column, RandomFourierFeatureMapper ja KernelLinearClassifier ovat poissa. Käytä tf.keras.layers.experimental.RandomFourierFeatures-tasoa Dense-tulostuksella tai RBFSampleria SGDClassifierin kanssa.

Automaattiset hakutyökalut käyvät läpi ytimen tyypin, asteen, gamman tai keskihajonnan ja regularisointivoimakkuuden rinnakkaisissa hakuajoissa ja luokittelevat ne sitten ristiinvalidoidun pistemäärän perusteella. Ne muuttavat ytimen valinnan mitatuksi vertailuksi, vaikka hakubudjetin ja pisteytysmittarin asetat edelleen.

Se luonnostelee telineet nopeasti: ominaisuuksien skaalauksen, kartoittajakutsun, estimaattorin ja arviointisilmukan. Käsittele ehdotuksia ensimmäisenä vaiheena, koska GitHub Copilot toistaa helposti poistetut TensorFlow 1.x -API-rajapinnat, joita ei enää tuoda nykyisissä julkaisuissa.

Se asettaa samankaltaisuuskellon leveyden. Pieni keskihajonta laskee vain hyvin lähellä olevat pisteet samankaltaisiksi, mikä tuottaa tiukan ja aaltoilevan rajan, joka voi ylisovittua. Suuri keskihajonta tasoittaa rajaa ja siirtää mallia takaisin kohti lineaarista sovitusta.

Se on Gaussin ytimen approksimoinnissa käytettyjen satunnaisten Fourier-ominaisuuksien lukumäärä. Useammat ominaisuudet approksimoivat ydintä tarkemmin ja yleensä parantavat tarkkuutta, mutta tämä laajemman painotusvektorin ja hitaamman opetuksen hinnalla jokaisella erällä.

Tarkka ydinmenetelmä vertaa jokaista harjoituspisteparia, joten kustannukset kasvavat suunnilleen otosmäärän neliön myötä. Satunnainen Fourier kiertää tämän approksimoimalla ydintä kiinteäleveydeisellä projektiolla.

Ytimen metodi korjaa ominaisuuskartanping etukäteen ja oppii vain lineaariset painot, joten se harjoittelee nopeasti vaatimattomalla datalla. neuroverkkomallien oppii oman esitystapansa, joka skaalautuu paremmin erittäin suuriin, strukturoimattomiin tietojoukkoihin, kuten kuviin.

Tiivistä tämä viesti seuraavasti: