Gaussova jezgra u strojnom učenju: Python Kernel metode
Evelyn Clarke
Svrha ovog vodiča je napraviti skup podataka linearno odvojivim. Vodič je podijeljen u dva dijela:
- Transformacija značajki
- Obučite kernel klasifikator s Tensorflowom
U prvom dijelu razumjet ćete ideju koja stoji iza metode kernela u strojnom učenju, dok ćete u drugom dijelu vidjeti kako trenirati kernel klasifikator s Tensorflowom. Koristit ćete skup podataka za odrasle. Cilj ovog skupa podataka je klasificirati prihod ispod i iznad 50 tisuća, poznavajući ponašanje svakog kućanstva.
Zašto su vam potrebne kernel metode?
Cilj svakog klasifikatora je točno predvidjeti klase. Za to bi skup podataka trebao biti odvojiv. Pogledajte radnju ispod; prilično je jednostavno vidjeti da sve točke iznad crne linije pripadaju prvoj klasi, a ostale točke drugoj klasi. Međutim, iznimno je rijetko imati tako jednostavan skup podataka. U većini slučajeva podaci se ne mogu odvojiti. Metode kernela u strojnom učenju otežavaju naivne klasifikatore poput logističke regresije.
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()
Na donjoj slici prikazujemo skup podataka koji nije linearno odvojiv. Ako nacrtamo ravnu crtu, većina točaka neće biti svrstana u točan razred.
Jedan od načina za rješavanje ovog problema je uzeti skup podataka i transformirati podatke u drugu kartu značajki. To znači da ćete koristiti funkciju za transformaciju podataka u drugom planu, koji bi trebao biti lineabilan.
x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18]) y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1]) label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1])
fig = plt.figure() plt.scatter(x, y, c=label, s=60) plt.show()
Podaci s gornje slike nalaze se u 2D Gaussovom planu kernela koji se ne može odvojiti. Možete pokušati transformirati te podatke u trodimenzionalnost, to znači da stvarate lik s 3 osi.
U našem primjeru Gaussove jezgre primijenit ćemo preslikavanje polinoma kako bismo svoje podatke doveli u 3D dimenziju. Formula za transformaciju podataka je sljedeća.
Vi definirate funkciju u Gaussovoj jezgri Python za izradu novih mapa značajki
Možete koristiti kvrgav za kodiranje gornje formule:
| Formula | Ekvivalentni Numpy kod |
|---|---|
| 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
Novo mapiranje bi trebalo biti trodimenzionalno sa 3 točaka
x_1 = mapping(x, y) x_1.shape
(3, 16)
Napravimo novi dijagram s 3 osi, x, y i z redom.
# 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()
Vidimo poboljšanje, ali ako promijenimo orijentaciju dijagrama, jasno je da se skup podataka sada može odvojiti
# 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()
Za manipuliranje velikim skupom podataka i možda ćete morati izraditi više od 2 dimenzije, suočit ćete se s velikim problemom koristeći gornju metodu. Zapravo, trebate transformirati sve podatkovne točke, što očito nije održivo. Trebat će vam puno vremena, a vašem računalu može ponestati memorije.
Najčešći način za prevladavanje ovog problema je korištenje a zrno.
Što je kernel u strojnom učenju?
Ideja je koristiti prostor značajki više dimenzije kako bi podaci bili gotovo linearno odvojivi kao što je prikazano na gornjoj slici.
Postoji mnogo prostora viših dimenzija kako bi se podatkovne točke mogle odvojiti. Na primjer, pokazali smo da je preslikavanje polinoma odličan početak.
Također smo pokazali da s puno podataka ta transformacija nije učinkovita. Umjesto toga, možete koristiti funkciju kernela u strojnom učenju za izmjenu podataka bez promjene na novom planu značajki.
Čarolija kernela je pronaći funkciju koja izbjegava sve probleme koje implicira visokodimenzionalno računanje. Rezultat kernela je skalar, ili drugačije rečeno, vratili smo se u jednodimenzionalni prostor
Nakon što pronađete ovu funkciju, možete je priključiti na standardni linearni klasifikator.
Pogledajmo primjer za razumijevanje koncepta kernel strojnog učenja. Imate dva vektora, x1 i x2. Cilj je stvoriti višu dimenziju korištenjem preslikavanja polinoma. Izlaz je jednak točkastom proizvodu nove karte značajki. Od gore navedene metode trebate:
- Transformirajte x1 i x2 u novu dimenziju
- Izračunajte točkasti umnožak: zajednički za sve jezgre
- Transformirajte x1 i x2 u novu dimenziju
Možete koristiti gore stvorenu funkciju za izračunavanje više dimenzije.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Izlaz
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Izračunajte točkasti umnožak
Možete koristiti objekt dot iz numpyja za izračunavanje točkastog produkta između prvog i drugog vektora pohranjenog u x_1.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Izlaz je 8100. Vidite problem, trebate pohraniti u memoriju novu mapu značajki za izračunavanje točkastog produkta. Ako imate skup podataka s milijunima zapisa, on je računski neučinkovit.
Umjesto toga, možete koristiti polinomska jezgra za izračunavanje točkastog produkta bez transformacije vektora. Ova funkcija izračunava točkasti umnožak x1 i x2 kao da su ta dva vektora transformirana u višu dimenziju. Drugim riječima, kernel funkcija izračunava rezultate točkastog produkta iz drugog prostora značajki.
Možete napisati polinomnu kernel funkciju Python kako slijedi.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
To je snaga točkastog produkta dva vektora. U nastavku vraćate drugi stupanj jezgre polinoma. Izlaz je jednak drugoj metodi. Ovo je magija kernela.
polynomial_kernel(x1, x2, p=2) 8100
Vrste kernel metoda
Dostupno je mnogo različitih Kernel tehnika. Najjednostavniji je linearni kernel. Ova funkcija radi prilično dobro za klasifikaciju teksta. Drugi kernel je:
- Polinomska jezgra
- Gaussova jezgra
U primjeru sa TensorFlow, koristit ćemo Slučajni Fourier. TensorFlow ima ugrađeni estimator za izračunavanje novog prostora značajki. Funkcija Gaussovog filtra je aproksimacija Gaussove kernel funkcije.
Funkcija Gaussovog filtriranja izračunava sličnost između podatkovnih točaka u mnogo većem dimenzionalnom prostoru.
Uvježbajte Gaussov kernel klasifikator s TensorFlowom
Cilj algoritma je klasificirati kućanstvo koje zarađuje više ili manje od 50k.
Procijenit ćete logističko strojno učenje regresije jezgre kako biste imali referentni model. Nakon toga, trenirat ćete kernel klasifikator da vidite možete li dobiti bolje rezultate.
Koristite sljedeće varijable iz skupa podataka za odrasle:
- starost
- radna klasa
- fnlwgt
- obrazovanje
- obrazovanje_br
- bračni
- okupacija
- odnos
- utrka
- seks
- kapitalni dobitak
- gubitak_kapitala
- sati_tjedan
- rodna_zemlja
- oznaka
Postupit ćete na sljedeći način prije nego što obučite i ocijenite model:
- Korak 1) Uvezite biblioteke
- Korak 2) Uvezite podatke
- Korak 3) Pripremite podatke
- Korak 4) Konstruirajte input_fn
- Korak 5) Konstruirajte logistički model: osnovni model
- Korak 6) Procijenite model
- Korak 7) Konstruirajte kernel klasifikator
- Korak 8) Procijenite kernel klasifikator
Korak 1) Uvezite biblioteke
Za uvoz i obuku kernel modela Umjetna inteligencija, trebate uvesti tensorflow, pande 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
Korak 2) Uvezite podatke
Podatke preuzimate sa sljedećeg web stranicu i uvozite ga kao panda dataframe.
## 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)
Sada kada su vlak i test skup definirani, možete promijeniti oznaku stupca iz niza u cijeli broj. tensorflow ne prihvaća vrijednost niza za oznaku.
label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]
df_train.shape
(32561, 15)
Korak 3) Pripremite podatke
Skup podataka sadrži kontinuirane i kategoričke značajke. Dobra praksa je standardizirati vrijednosti kontinuiranih varijabli. Možete koristiti funkciju StandardScaler iz sci-kit learna. Također stvarate korisnički definiranu funkciju kako biste olakšali pretvaranje vlaka i testnog skupa. Imajte na umu da spajate kontinuirane i kategoričke varijable u zajednički skup podataka, a niz bi trebao biti tipa: float32
COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
from sklearn.preprocessing import 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
Funkcija transformatora je spremna, možete pretvoriti skup podataka i izraditi funkciju input_fn.
X_train, y_train = prep_data_str(df_train) X_test, y_test = prep_data_str(df_test) print(X_train.shape) (32561, 14)
U sljedećem koraku trenirat ćete logističku regresiju. To će vam dati osnovnu točnost. Cilj je nadmašiti osnovnu liniju drugačijim algoritmom, naime klasifikatorom kernela.
Korak 4) Konstruirajte logistički model: Osnovni model
Stupac značajki konstruirate s objektom real_valued_column. Pobrinut će se da sve varijable budu gusti numerički podaci.
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
Procjenitelj se definira pomoću TensorFlow Estimatora, vi upućujete stupce značajki i gdje treba spremiti grafikon.
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}
Vježbat ćete logičku regresiju koristeći mini serije veličine 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)
Možete trenirati model s 1.000 ponavljanja
estimator.train(input_fn=train_input_fn, steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into kernel_log/model.ckpt. INFO:tensorflow:loss = 138.62949, step = 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>
Korak 6) Ocijenite model
Vi definirate numpy procjenitelj za procjenu modela. Za procjenu koristite cijeli skup podataka
# 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}
Imate točnost od 82 posto. U sljedećem odjeljku pokušat ćete pobijediti logistički klasifikator pomoću Kernel klasifikatora
Korak 7) Konstruirajte kernel klasifikator
Kernel estimator nije toliko različit od tradicionalnog linearnog klasifikatora, barem u smislu konstrukcije. Ideja koja stoji iza je korištenje moći eksplicitne jezgre s linearnim klasifikatorom.
Potrebna su vam dva unaprijed definirana procjenitelja dostupna u TensorFlowu za obuku Kernel Classifier-a:
- RandomFourierFeatureMapper
- KernelLinearClassifier
Naučili ste u prvom odjeljku da trebate transformirati nisku dimenziju u visoku pomoću kernel funkcije. Točnije, koristit ćete slučajni Fourier, koji je aproksimacija Gaussove funkcije. Srećom, Tensorflow ima funkciju u svojoj biblioteci: RandomFourierFeatureMapper. Model se može trenirati pomoću estimatora KernelLinearClassifier.
Da biste izradili model, slijedite ove korake:
- Postavite kernel funkciju visoke dimenzije
- Postavite hiperparametar L2
- Izgradite model
- Uvježbajte model
- Ocijenite model
Korak A) Postavite kernel funkciju visoke dimenzije
Trenutačni skup podataka sadrži 14 značajki koje ćete transformirati u novu visoku dimenziju vektora od 5.000 dimenzija. Za postizanje transformacije koristite nasumične Fourierove značajke. Ako se prisjetite formule Gaussove jezgre, primijetit ćete da postoji parametar standardne devijacije koji treba definirati. Ovaj parametar kontrolira mjeru sličnosti koja se koristi tijekom klasifikacije.
Možete podesiti sve parametre u RandomFourierFeatureMapper pomoću:
- 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')
Morate konstruirati kernel mapper korištenjem stupaca značajki kreiranih prije: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Korak B) Postavite hiperparametar L2
Kako biste spriječili prekomjerno opremanje, funkciju gubitka penalizirate regulatorom L2. Hiperparametar L2 postavite na 0.1 i brzinu učenja na 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
korak C) Izgradite model
Sljedeći korak sličan je linearnoj klasifikaciji. Koristite ugrađeni procjenitelj KernelLinearClassifier. Imajte na umu da dodajete prethodno definirani maper jezgre i mijenjate direktorij modela.
### 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'}
Korak D) Uvježbajte model
Sada kada je kernel klasifikator izgrađen, spremni ste ga trenirati. Vi odlučujete ponoviti model 2000 puta
### 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>]}})
korak E) Ocijenite model
Posljednje, ali ne manje važno, vi ocjenjujete izvedbu svog modela. Trebali biste moći pobijediti logističku regresiju.
# 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
Konačna točnost je 84%, to je poboljšanje od 2% u usporedbi s logističkom regresijom. Postoji kompromis između poboljšanja točnosti i troškova računanja. Morate razmisliti je li poboljšanje od 2% vrijedno vremena koje je potrošio različiti klasifikator i ima li uvjerljiv učinak na vaše poslovanje.
rezime
Kernel je izvrstan alat za pretvaranje nelinearnih podataka u (gotovo) linearne. Nedostatak ove metode je što je računski zahtjevan i skup.
U nastavku možete pronaći najvažniji kod za obuku klasifikatora jezgre
Postavite kernel funkciju visoke dimenzije
- 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')
Postavite hiperparametar L2
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Izgradite model
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
Uvježbajte model
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
Ocijenite model
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
