Poate GitHub Copilot să scrie cod pentru clasificatorul de kernel?

Elaborează rapid scheletajul: scalarea caracteristicilor, apelul mapperului, estimatorul și bucla de evaluare. Tratați sugestiile ca o primă trecere, deoarece GitHub Copilot reproduce cu ușurință API-urile TensorFlow 1.x eliminate care nu se mai importă în versiunile actuale.

Cum se compară metodele kernel cu rețelele neuronale?

O metodă kernel corectează harta caracteristicilorping în avans și învață doar ponderile liniare, deci se antrenează rapid pe date modeste. O rețea neuronală își învață propria reprezentare, care se scalează mai bine la seturi de date foarte mari, nestructurate, cum ar fi imaginile.

Kernel gaussian în învățare automată: Python Metode Kernel

⚡ Rezumat inteligent

Metodele kernelului gaussian fac ca datele neseparabile să fie liniar separabile fără a construi vreodată o hartă de caracteristici de înaltă dimensionalitate. Această demonstrație prezintă harta polinomială.ping manual, apoi antrenează un clasificator nucleu Fourier aleatoriu în TensorFlow.

🔘 Problema separabilității: Clasificatorii liniari eșuează ori de câte ori nicio linie dreaptă nu împarte clasele în spațiul de caracteristici original.
☑️ Harta polinomialăping: Transformarea în x la pătrat, xy la rădăcina de doi și y la pătrat ridică două dimensiuni în trei și separă datele eșantion.
✅ Truc cu nucleul: Un nucleu returnează direct produsul scalar al vectorilor mapați, deci nu este stocată niciodată o hartă extinsă a caracteristicilor.
🧪 Trei nuclee: Clasificarea liniară se potrivește clasificării textului, polinomul surprinde interacțiunile caracteristicilor, iar RBF gaussian măsoară similaritatea bazată pe distanță.
🛠️ Construcție TensorFlow: RandomFourierFeatureMapper proiectează 14 caracteristici în 5,000 de dimensiuni înainte ca KernelLinearClassifier să se antreneze cu un optimizator Ftrl.
📈 Rezultat măsurat: Clasificatorul kernel atinge o precizie de 0.83975184 față de 0.82353663 pentru linia de bază logistică.

Citește mai mult

Scopul acestui tutorial este de a face un set de date separabil liniar. Tutorialul este împărțit în două părți:

Transformarea caracteristicilor
Antrenează un clasificator Kernel cu TensorFlow

În prima parte, veți înțelege ideea din spatele unei metode Kernel în Machine Learning, în timp ce în a doua parte veți vedea cum să antrenați un clasificator de kernel cu TensorFlowVeți utiliza setul de date pentru adulți. Obiectivul acestui set de date este de a clasifica veniturile sub și peste 50, cunoscând comportamentul fiecărei gospodării.

De ce aveți nevoie de Metode Kernel?

Scopul fiecărui clasificator este de a prezice corect clasele. Pentru aceasta, setul de date ar trebui să fie separabil. Priviți graficul de mai jos; este destul de simplu să observați că toate punctele de deasupra liniei negre aparțin primei clase, iar celelalte puncte celei de-a doua clase. Cu toate acestea, este extrem de rar să existe un set de date atât de simplu. În majoritatea cazurilor, datele nu sunt separabile, iar datele care nu sunt separabile pun în dificultate clasificatorii naivi, cum ar fi regresia logistică.

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], &#x27;k-', lw=2)
  ax.set_xlim([-5,15])
  ax.set_ylim([-5,15])plt.show()

În figura de mai jos, reprezentăm grafic un set de date care nu este separabil liniar. Dacă trasăm o linie dreaptă, majoritatea punctelor nu vor fi clasificate în clasa corectă.

O modalitate de a aborda această problemă este de a lua setul de date și de a transforma datele într-o altă hartă de caracteristici. Aceasta înseamnă că veți utiliza o funcție pentru a muta datele într-un alt plan, unul care ar trebui să fie liniar separabil.

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

Datele din figura de mai sus se află într-un plan 2D și nu sunt separabile. Puteți încerca să transformați aceste date în trei dimensiuni, ceea ce înseamnă că creați o figură cu 3 axe.

În exemplul nostru cu nucleul gaussian, vom aplica o aplicație polinomialăping pentru a aduce datele noastre într-o a treia dimensiune. Formula de transformare a datelor este următoarea.

Definiți o funcție în Kernel Gaussian Python pentru a crea noile hărți ale caracteristicilor.

Poți să folosești NumPy pentru a codifica formula de mai sus. Fiecare rând de mai jos împerechează câte un termen al hărțiiping cu expresia matriceală care o produce, iar imaginea mică marchează rădăcina pătrată a doi factori.

Formulă	Cod NumPy echivalent
x	x[:,0]
y	x[:,1]
x²	x[:,0]***2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	x[:,1]***2

### illustration purpose
def mapping(x, y):    
	x = np.c_[(x, y)]				
    if len(x) >	2:        
    	x_1 = x[:,0]**2        
        x_2 = np.sqrt(2)*x[:,0]*x[:,1]        
        x_3 = x[:,1]**2								
    else:            
    	x_1 = x[0]**2        
        x_2 = np.sqrt(2)*x[0]*x[1]        
        x_3 = x[1]**2			    
   trans_x = np.array([x_1, x_2, x_3])				
   return trans_x

Noua hartăping are 3 dimensiuni și 16 puncte.

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Acum creați un nou grafic cu 3 axe, x, y și respectiv z.

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection=&#x27;3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')
plt.show()

Observăm o îmbunătățire, dar dacă schimbăm orientarea graficului, devine clar că setul de date este acum separabil.

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection=&#x27;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(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')plt.show()

Dacă trebuie să manipulați un set mare de date și să creați mai mult de 2 dimensiuni, veți întâmpina o problemă majoră cu metoda de mai sus. De fapt, trebuie să transformați toate punctele de date, ceea ce evident nu este sustenabil. Vă va lua o veșnicie, iar computerul ar putea rămâne fără memorie.

Cea mai obișnuită metodă de a depăși această problemă este utilizarea unui kernel.

Ce este un kernel în învățarea automată?

Ideea este de a utiliza un spațiu de caracteristici de dimensiune superioară pentru a face datele separabile aproape liniar, așa cum se arată în figura de mai sus.

Există o mulțime de spații de dimensiuni superioare care fac ca punctele de date să fie separabile. De exemplu, am arătat că aplicația polinomialăping este un început grozav.

De asemenea, am demonstrat că, în cazul unor volume mari de date, aceste transformări nu sunt eficiente. În schimb, puteți utiliza o funcție Kernel în Machine Learning pentru a modifica datele fără a trece la un nou plan de caracteristici.

Magia nucleului constă în găsirea unei funcții care evită toate problemele implicate de calculul multidimensional. Rezultatul unui nucleu este un scalar sau, altfel spus, ne întoarcem în spațiul unidimensional.

După ce ați găsit această funcție, o puteți conecta la clasificatorul liniar standard.

Iată un exemplu care concretizează conceptul de Kernel Machine Learning. Aveți doi vectori, x1 și x2. Obiectivul este de a crea o dimensiune superioară folosind o hartă polinomială.pingRezultatul este egal cu produsul scalar al noii hărți de caracteristici. Conform metodei de mai sus, trebuie să:

Transformă x1 și x2 într-o nouă dimensiune
Calculați produsul punctual: comun tuturor nucleelor

Transformă x1 și x2 într-o nouă dimensiune

Puteți utiliza funcția creată mai sus pentru a calcula dimensiunea superioară.

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

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

producție

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

Calculați produsul punctual

Puteți folosi punctul obiectului din NumPy pentru a calcula produsul scalar dintre primul și al doilea vector stocat în x_1.

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

Rezultatul este 8100. Vedeți problema: trebuie să stocați o nouă hartă a caracteristicilor în memorie pentru a calcula produsul scalar. Dacă aveți un set de date cu milioane de înregistrări, acesta este ineficient din punct de vedere computațional.

În schimb, puteți utiliza nucleul polinomial pentru a calcula produsul scalar fără a transforma vectorul. Această funcție calculează produsul scalar dintre x1 și x2 ca și cum acești doi vectori ar fi fost transformați în dimensiunea superioară. Cu alte cuvinte, o funcție nucleu calculează rezultatul produsului scalar dintr-un alt spațiu de caracteristici.

Puteți scrie funcția kernel polinomială în Python după cum urmează.

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

Este puterea produsului scalar a doi vectori. Mai jos, returnați gradul doi al nucleului polinom. Ieșirea este egală cu cealaltă metodă. Aceasta este magia nucleului.

polynomial_kernel(x1, x2, p=2)			
8100

Tipuri de Metode Kernel

Există o mulțime de tehnici diferite de kernel disponibile. Cea mai simplă este kernelul liniar. Această funcție funcționează destul de bine pentru clasificarea textului. Celelalte kerneluri sunt:

Nucleu polinom
Kernel gaussian

Tabelul de mai jos prezintă pe scurt ce face fiecare și când practicienii o aplică.

Nucleu	Ceea ce calculează	Utilizare tipică
Liniar	Produsul scalar simplu în spațiul original al caracteristicilor	Date deja separabile și caracteristici de text de înaltă dimensiune
polinom	Produsul scalar ridicat la un grad p, care captează interacțiunile dintre caracteristici	Limite curbate atunci când se știe că interacțiunile contează
Gaussiană (RBF)	O similaritate bazată pe distanță care scade spre zero pe măsură ce punctele se depărtează	Prima opțiune obișnuită atunci când forma limitei este necunoscută

În exemplul cu TensorFlow, vom folosi caracteristici Fourier aleatorii. TensorFlow are un estimator încorporat pentru a calcula noul spațiu de caracteristici. Mapătorul de caracteristici Fourier aleatoriu este o aproximare a funcției kernel gaussian prezentată mai jos.

Funcția de filtrare gaussiană calculează similitudinea dintre punctele de date dintr-un spațiu dimensional mult mai mare.

Odată ce teoria este clarificată, restul acestei etape ajută la lucrul cu un nucleu gaussian pe un set de date real.

Antrenează clasificatorul Gaussian Kernel cu TensorFlow

Obiectivul algoritmului este de a clasifica gospodăria care câștigă mai mult sau mai puțin de 50k.

Mai întâi veți evalua o regresie logistică pentru a avea un model de referință. După aceea, veți antrena un clasificator Kernel pentru a vedea dacă puteți obține rezultate mai bune.

Utilizați următoarele variabile din setul de date pentru adulți:

vârstă
clasa de lucru
fnlwgt
educaţie
educație_num
marital
ocupație
relaţie
rasă
sex
câștig de capital
pierdere_capital
ore_săptămână
tara de origine
etichetă

Veți proceda după cum urmează înainte de a antrena și evalua modelul:

Importă bibliotecile
Importă datele
Pregătiți datele
Construiți modelul logistic: modelul de bază
Evaluați modelul
Construiți și evaluați clasificatorul Kernel

Notă privind versiunea: Fiecare fragment de mai jos vizează TensorFlow 1.x. Spațiul de nume tf.contrib, care furnizează real_valued_column, RandomFourierFeatureMapper și KernelLinearClassifier, a fost eliminat în TensorFlow 2.0, iar tf.estimator în sine a fost eliminat în TensorFlow 2.16. Într-o versiune curentă, construiți aceeași conductă cu stratul tf.keras.layers.experimental.RandomFourierFeatures urmat de un strat de ieșire Dense sau cu perechea RBFSampler și SGDClassifier din scikit-learn.

Pasul 1) Importați bibliotecile

Pentru a importa și antrena modele Kernel în Inteligența artificială , trebuie să importați TensorFlow, panda și 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

Pasul 2) Importați datele

Descărcați datele de pe Pagina setului de date UCI pentru adulți și importați-l ca un DataFrame pandas.

## Define path data
COLUMNS = [&#x27;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)

Acum, că trenul și setul de testare sunt definite, puteți schimba eticheta coloanei din șir de caractere în număr întreg. TensorFlow nu acceptă valori de tip șir de caractere pentru etichetă.

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)

Pasul 3) Pregătiți datele

Setul de date conține atât caracteristici continue, cât și categorice. O bună practică este standardizarea valorilor variabilelor continue. Puteți utiliza funcția StandardScaler din scikit-learnDe asemenea, creați o funcție definită de utilizator pentru a facilita conversia setului de tren și a setului de testare. Rețineți că concatenați variabilele continue și categorice într-un set de date comun, iar matricea trebuie să fie de tip 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

Funcția transformer este gata, așa că puteți converti setul de date și crea funcția 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)

În pasul următor, veți antrena o regresie logistică. Vă va oferi o precizie de referință. Obiectivul este de a depăși linia de bază cu un alt algoritm, și anume un clasificator Kernel.

Pasul 4) Construiți modelul logistic: Modelul de bază

Construiți coloana caracteristică cu obiectul real_valued_column. Se va asigura că toate variabilele sunt date numerice dense.

feat_column = tf.contrib.layers.real_valued_column(&#x27;features', dimension=14)

Estimatorul este definit folosind API-ul TensorFlow Estimator; furnizați coloanele de caracteristici și locul unde se salvează graficul.

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}

Vei antrena regresia logistică folosind mini-loturi de dimensiunea 200.

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

Puteți antrena modelul cu 1,000 de iterații.

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>

Pasul 5) Evaluați modelul

Definiți funcția de intrare NumPy pentru a evalua modelul. Folosiți întregul set de teste pentru evaluare.

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

Ai o precizie de 82%. În secțiunea următoare, vei încerca să depășești clasificatorul logistic cu un clasificator Kernel.

Pasul 6) Construiți clasificatorul Kernel

Estimatorul kernel nu este foarte diferit de clasificatorul liniar tradițional, cel puțin în ceea ce privește construcția. Ideea din spatele său este de a combina puterea unei hărți kernel expliciteping cu clasificatorul liniar.

Aveți nevoie de doi estimatori predefiniti disponibili în TensorFlow pentru a antrena Kernel Clasifier:

RandomFourierFeatureMapper
KernelLinearClassifier

Ai învățat în prima secțiune că trebuie să transformi dimensiunea mică într-o dimensiune mare folosind o funcție kernel. Mai precis, vei utiliza caracteristici Fourier aleatorii, care aproximează funcția gaussiană. TensorFlow 1.x furnizează această hartăping ca RandomFourierFeatureMapper, iar modelul poate fi antrenat folosind estimatorul KernelLinearClassifier.

Pentru a construi modelul, veți urma acești pași:

Setați funcția Kernel de dimensiune mare
Setați hiperparametrul L2
Construiți modelul
Antrenează modelul
Evaluați modelul

Pasul A) Setați funcția Kernel de dimensiuni mari

Setul de date curent conține 14 caracteristici pe care le veți transforma într-un nou vector de 5,000 de dimensiuni. Folosiți caracteristicile Fourier aleatorii pentru a realiza transformarea. Dacă vă amintiți formula nucleului gaussian, observați că există un parametru de deviație standard de definit. Acest parametru controlează măsura de similaritate utilizată în timpul clasificării: o valoare mică a deviației standard face ca nucleul să trateze doar punctele foarte apropiate ca fiind similare, în timp ce una mare netezește limita de decizie.

Puteți regla toți parametrii în RandomFourierFeatureMapper cu:

input_dim = 14
output_dim = 5000
dev.standard = 4

### Prep Kernel
kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name=&#x27;rffm')

Trebuie să construiți mapatorul nucleului utilizând coloanele de caracteristici create înainte: feat_column

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

Pasul B) Setați hiperparametrul L2

Pentru a preveni supraadaptarea, penalizezi funcția de pierdere cu regularizatorul L2. Setezi hiperparametrul L2 la 0.1 și rata de învățare la 5.

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

Pasul C) Construirea modelului

Următorul pas este similar cu clasificarea liniară. Folosiți estimatorul încorporat KernelLinearClassifier. Rețineți că adăugați mapper-ul de kernel definit anterior și modificați directorul modelului.

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

Avertismentele de depreciere de mai jos sunt așteptate pe TensorFlow 1.x, deoarece modulul kernel_methods este construit pe estimatorii tf.contrib.learn mai vechi.

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

Pasul D) Antrenarea modelului

Acum că clasificatorul Kernel este construit, sunteți gata să îl antrenați. Alegi să iterezi modelul de 2,000 de ori.

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

Pasul E) Evaluarea modelului

Nu în ultimul rând, evaluezi performanța modelului tău. Ar trebui să poți învinge regresia logistică.

# 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

Precizia finală este de 84%, cu aproximativ 1.6 puncte procentuale peste valoarea de referință a regresiei logistice (0.83975184 față de 0.82353663). Există un compromis între îmbunătățirea preciziei și costul de calcul. Trebuie să vă gândiți dacă această îmbunătățire merită timpul consumat de clasificatorul mai complex și dacă are un impact convingător asupra afacerii dumneavoastră.

Întrebări frecvente

Trucul kernelului calculează produsul scalar pe care l-ar avea doi vectori după o hartă de dimensiuni mariping, fără a construi vreodată acea hartăpingFuncția polynomial_kernel din acest tutorial returnează direct 8100, aceeași valoare produsă de transformarea tridimensională explicită.

Nu, tf.contrib a fost eliminat în TensorFlow 2.0 și tf.estimator în 2.16, așadar real_valued_column, RandomFourierFeatureMapper și KernelLinearClassifier au dispărut. Folosește stratul tf.keras.layers.experimental.RandomFourierFeatures cu o ieșire Dense sau RBFSampler cu SGDClassifier.

Instrumentele automate de căutare analizează tipul, gradul, gamma sau stddev-ul kernelului și puterea de regularizare în rulări paralele, apoi le clasifică în funcție de scorul validat încrucișat. Acestea transformă selecția kernelului într-o comparație măsurată, deși setați în continuare bugetul de căutare și metrica de scor.

Elaborează rapid scheletul: scalarea caracteristicilor, apelul mapperului, estimatorul și bucla de evaluare. Tratați sugestiile ca pe o primă trecere, deoarece Copilotul GitHub reproduce cu ușurință API-urile TensorFlow 1.x eliminate care nu se mai importă în versiunile curente.

Setează lățimea clopotului de similaritate. O valoare mică a valorii stddev face ca doar punctele foarte apropiate să fie considerate similare, producând o limită strânsă, ondulată, care poate fi suprasolicitată. O valoare mare a valorii stddev netezește limita și deplasează modelul înapoi către o ajustare liniară.

Este numărul de caracteristici Fourier aleatorii utilizate pentru a aproxima nucleul gaussian. Mai multe caracteristici aproximează nucleul mai îndeaproape și, de obicei, cresc precizia, cu prețul unui vector de ponderi mai larg și al unui antrenament mai lent pe fiecare lot.

O metodă cu kernel exact compară fiecare pereche de puncte de antrenament, astfel încât costul crește aproximativ odată cu pătratul numărului de eșantioane. Caracteristicile Fourier aleatoare evită acest lucru prin aproximarea kernelului cu o proiecție cu lățime fixă.

O metodă kernel corectează harta caracteristicilorping în avans și învață doar ponderile liniare, deci se antrenează rapid pe date modeste. A rețele neuronale învață propria reprezentare, care se scalează mai bine la seturi de date foarte mari, nestructurate, cum ar fi imaginile.

Kernel gaussian în învățare automată: Python Metode Kernel

De ce aveți nevoie de Metode Kernel?

Ce este un kernel în învățarea automată?

Transformă x1 și x2 într-o nouă dimensiune

Calculați produsul punctual

Tipuri de Metode Kernel

Antrenează clasificatorul Gaussian Kernel cu TensorFlow

Pasul 1) Importați bibliotecile

Pasul 2) Importați datele

Pasul 3) Pregătiți datele

Pasul 4) Construiți modelul logistic: Modelul de bază

Pasul 5) Evaluați modelul

Pasul 6) Construiți clasificatorul Kernel

Pasul A) Setați funcția Kernel de dimensiuni mari

Pasul B) Setați hiperparametrul L2

Pasul C) Construirea modelului

Pasul D) Antrenarea modelului

Pasul E) Evaluarea modelului

Întrebări frecvente

Rezumați această postare cu:

Înscrieți-vă la newsletter

De ce aveți nevoie de Metode Kernel?

Ce este un kernel în învățarea automată?

Transformă x1 și x2 într-o nouă dimensiune

Calculați produsul punctual

ARTICOLE SIMILARE

Tipuri de Metode Kernel

Antrenează clasificatorul Gaussian Kernel cu TensorFlow

Pasul 1) Importați bibliotecile

Pasul 2) Importați datele

Pasul 3) Pregătiți datele

Pasul 4) Construiți modelul logistic: Modelul de bază

Pasul 5) Evaluați modelul

Pasul 6) Construiți clasificatorul Kernel

Pasul A) Setați funcția Kernel de dimensiuni mari

Pasul B) Setați hiperparametrul L2

Pasul C) Construirea modelului

Pasul D) Antrenarea modelului

Pasul E) Evaluarea modelului

Întrebări frecvente

Rezumați această postare cu:

Înscrieți-vă la newsletter