Gaussisk kjerne i maskinlæring: Python Kjernemetoder
Hensikten med denne opplæringen er å gjøre et datasett lineært separerbart. Opplæringen er delt inn i to deler:
- Funksjonstransformasjon
- Tren en kjerneklassifiser med Tensorflow
I den første delen vil du forstå ideen bak en kjernemetode i maskinlæring, mens du i den andre delen vil se hvordan du trener en kjerneklassifiser med Tensorflow. Du vil bruke voksendatasettet. Målet med dette datasettet er å klassifisere inntektene under og over 50k, vel vitende om oppførselen til hver husholdning.
Hvorfor trenger du kjernemetoder?
Målet med hver klassifiserer er å forutsi klassene riktig. For det bør datasettet være separerbart. Se på plottet nedenfor; det er ganske enkelt å se at alle punktene over den svarte linjen tilhører den første klassen og de andre punktene til den andre klassen. Det er imidlertid ekstremt sjeldent å ha et datasett så enkelt. I de fleste tilfeller er ikke dataene separerbare. Kjernemetoder i Machine Learning gir naive klassifiserere som en logistisk regresjon en vanskelig tid.
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()
I figuren nedenfor plotter vi et datasett som ikke er lineært separerbart. Hvis vi trekker en rett linje, vil de fleste punktene ikke bli klassifisert i riktig klasse.
En måte å takle dette problemet på er å ta datasettet og transformere dataene til et annet funksjonskart. Det betyr at du vil bruke en funksjon til å transformere dataene i en annen plan, som bør være lineærbar.
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()
Dataene fra figuren ovenfor er i en 2D Gaussisk kjerneplan som ikke kan separeres. Du kan prøve å transformere disse dataene i en tredimensjon, det betyr at du lager en figur med 3 akser.
I vårt Gaussian Kernel-eksempel vil vi bruke en polynomkartlegging for å bringe dataene våre til en 3D-dimensjon. Formelen for å transformere dataene er som følger.
Du definerer en funksjon i Gaussian Kernel Python for å lage de nye funksjonskartene
Du kan bruke følelsesløs for å kode formelen ovenfor:
Formel | Tilsvarende Numpy-kode |
---|---|
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
Den nye kartleggingen skal være med 3 dimensjoner med 16 punkter
x_1 = mapping(x, y) x_1.shape
(3, 16)
La oss lage et nytt plott med henholdsvis 3 akser, x, y og 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()
Vi ser en forbedring, men hvis vi endrer retningen på plottet, er det klart at datasettet nå kan separeres
# 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()
For å manipulere et stort datasett, og du må kanskje lage mer enn 2 dimensjoner, vil du møte et stort problem ved å bruke metoden ovenfor. Faktisk må du transformere alle datapunkter, noe som tydeligvis ikke er bærekraftig. Det vil ta lang tid, og datamaskinen kan gå tom for minne.
Den vanligste måten å løse dette problemet på er å bruke en kjerne.
Hva er en kjerne i maskinlæring?
Ideen er å bruke et funksjonsrom med høyere dimensjon for å gjøre dataene nesten lineært separerbare som vist i figuren ovenfor.
Det er nok av høyere dimensjonale rom for å gjøre datapunktene separerbare. For eksempel har vi vist at polynomkartleggingen er en god start.
Vi har også vist at med mye data er ikke denne transformasjonen effektiv. I stedet kan du bruke en kjernefunksjon i maskinlæring for å endre dataene uten å endre til en ny funksjonsplan.
Magien med kjernen er å finne en funksjon som unngår alle problemene som følger av den høydimensjonale beregningen. Resultatet av en kjerne er en skalar, eller sagt annerledes er vi tilbake til endimensjonalt rom
Etter at du har funnet denne funksjonen, kan du koble den til standard lineær klassifiserer.
La oss se et eksempel for å forstå konseptet Kernel Machine Learning. Du har to vektorer, x1 og x2. Målet er å skape en høyere dimensjon ved å bruke en polynomkartlegging. Utgangen er lik prikkproduktet til det nye funksjonskartet. Fra metoden ovenfor må du:
- Forvandle x1 og x2 til en ny dimensjon
- Beregn punktproduktet: felles for alle kjerner
- Forvandle x1 og x2 til en ny dimensjon
Du kan bruke funksjonen opprettet ovenfor for å beregne den høyere dimensjonen.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Produksjon
[[ 9. 100. ] [ 25.45584412 141.42135624] [ 36. 100. ]]
Beregn punktproduktet
Du kan bruke objektprikken fra numpy til å beregne punktproduktet mellom den første og andre vektoren lagret i x_1.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Utgangen er 8100. Du ser problemet, du må lagre et nytt funksjonskart i minnet for å beregne punktproduktet. Hvis du har et datasett med millioner av poster, er det beregningsmessig ineffektivt.
I stedet kan du bruke polynom kjerne å beregne punktproduktet uten å transformere vektoren. Denne funksjonen beregner punktproduktet til x1 og x2 som om disse to vektorene har blitt transformert til den høyere dimensjonen. Sagt annerledes, en kjernefunksjon beregner resultatene av punktproduktet fra et annet funksjonsområde.
Du kan skrive polynomets kjernefunksjon i Python som følger.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Det er kraften til punktproduktet av to vektorer. Nedenfor returnerer du den andre graden av polynomkjernen. Utgangen er lik den andre metoden. Dette er magien med kjernen.
polynomial_kernel(x1, x2, p=2) 8100
Typer kjernemetoder
Det er mange forskjellige kjerneteknikker tilgjengelig. Den enkleste er den lineære kjernen. Denne funksjonen fungerer ganske bra for tekstklassifisering. Den andre kjernen er:
- Polynom kjerne
- Gaussisk kjerne
I eksempelet med tensorflow, vil vi bruke Random Fourier. TensorFlow har en innebygd estimator for å beregne den nye funksjonsplassen. Den Gaussiske filterfunksjonen er en tilnærming av den Gaussiske kjernefunksjonen.
Den Gaussiske filtreringsfunksjonen beregner likheten mellom datapunktene i et mye høyere dimensjonalt rom.
Tren Gaussian Kernel-klassifiserer med TensorFlow
Målet med algoritmen er å klassifisere husholdningen som tjener mer eller mindre enn 50k.
Du vil evaluere en logistisk kjerneregresjonsmaskinlæring for å ha en benchmarkmodell. Etter det vil du trene en kjerneklassifiser for å se om du kan få bedre resultater.
Du bruker følgende variabler fra voksendatasettet:
- alder
- arbeidsklasse
- fnlwgt
- utdanning
- utdanning_nummer
- ekteskapelig
- okkupasjon
- forholdet
- rase
- kjønn
- kapitalgevinst
- kapitaltap
- timer_uke
- native_country
- etikett
Du vil gå frem som følger før du trener og evaluerer modellen:
- Trinn 1) Importer bibliotekene
- Trinn 2) Importer dataene
- Trinn 3) Forbered dataene
- Trinn 4) Konstruer input_fn
- Trinn 5) Konstruer logistikkmodellen: Grunnmodell
- Trinn 6) Vurder modellen
- Trinn 7) Konstruer kjerneklassifikatoren
- Trinn 8) Evaluer kjerneklassifikatoren
Trinn 1) Importer bibliotekene
For å importere og trene kjernemodeller i Kunstig intelligens, du må importere tensorflow, pandaer og nusset
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Trinn 2) Importer dataene
Du laster ned dataene fra følgende nettsted og du importerer den som en panda-dataramme.
## 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)
Nå som toget og testsettet er definert, kan du endre kolonneetiketten fra streng til heltall. tensorflow godtar ikke strengverdi for etiketten.
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)
Trinn 3) Forbered dataene
Datasettet inneholder både kontinuerlige og kategoriske trekk. En god praksis er å standardisere verdiene til de kontinuerlige variablene. Du kan bruke funksjonen StandardScaler fra sci-kit learning. Du oppretter også en brukerdefinert funksjon for å gjøre det enklere å konvertere toget og testsettet. Merk at du kobler sammen de kontinuerlige og kategoriske variablene til et felles datasett og matrisen bør være av typen: 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
Transformatorfunksjonen er klar, du kan konvertere datasettet og lage input_fn-funksjonen.
X_train, y_train = prep_data_str(df_train) X_test, y_test = prep_data_str(df_test) print(X_train.shape) (32561, 14)
I neste trinn skal du trene en logistisk regresjon. Det vil gi deg en grunnlinjenøyaktighet. Målet er å slå grunnlinjen med en annen algoritme, nemlig en kjerneklassifikator.
Trinn 4) Konstruer logistikkmodellen: Grunnmodell
Du konstruerer funksjonskolonnen med objektet real_valued_column. Det vil sørge for at alle variabler er tette numeriske data.
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
Estimatoren er definert ved hjelp av TensorFlow Estimator, du instruerer funksjonskolonnene og hvor grafen skal lagres.
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}
Du vil trene den logiske regresjonen ved å bruke minibatcher i størrelse 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)
Du kan trene modellen med 1.000 iterasjoner
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>
Trinn 6) Evaluer modellen
Du definerer numpy estimatoren for å evaluere modellen. Du bruker hele datasettet for evaluering
# 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}
Du har en nøyaktighet på 82 prosent. I neste avsnitt vil du prøve å slå den logistiske klassifisereren med en kjerneklassifiserer
Trinn 7) Konstruer kjerneklassifikatoren
Kjerneestimatoren er ikke så forskjellig fra den tradisjonelle lineære klassifikatoren, i det minste når det gjelder konstruksjon. Ideen bak er å bruke kraften til eksplisitt kjerne med den lineære klassifikatoren.
Du trenger to forhåndsdefinerte estimatorer som er tilgjengelige i TensorFlow for å trene opp Kernel Classifier:
- RandomFourierFeatureMapper
- KernelLinearClassifier
Du lærte i den første delen at du må transformere den lave dimensjonen til en høy dimensjon ved hjelp av en kjernefunksjon. Mer presist vil du bruke Random Fourier, som er en tilnærming av Gauss-funksjonen. Heldigvis har Tensorflow funksjonen i biblioteket: RandomFourierFeatureMapper. Modellen kan trenes ved å bruke estimatoren KernelLinearClassifier.
For å bygge modellen, følger du disse trinnene:
- Angi kjernefunksjonen med høy dimensjon
- Still inn L2-hyperparameteren
- Bygg modellen
- Tren modellen
- Evaluer modellen
Trinn A) Angi kjernefunksjonen med høy dimensjon
Det gjeldende datasettet inneholder 14 funksjoner som du vil transformere til en ny høy dimensjon av den 5.000-dimensjonale vektoren. Du bruker de tilfeldige Fourier-funksjonene for å oppnå transformasjonen. Hvis du husker den Gaussiske kjerneformelen, merker du at det er standardavviksparameteren som skal defineres. Denne parameteren kontrollerer for likhetsmålet som brukes under klassifiseringen.
Du kan justere alle parameterne i RandomFourierFeatureMapper med:
- 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')
Du må konstruere kjernekartleggingen ved å bruke funksjonskolonnene opprettet før: feat_column
### Map Kernel kernel_mappers = {feat_column: [kernel_mapper]}
Trinn B) Still inn L2-hyperparameteren
For å forhindre overtilpasning straffer du tapsfunksjonen med L2-regularizeren. Du setter L2-hyperparameteren til 0.1 og læringshastigheten til 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Trinn C) Bygg modellen
Det neste trinnet ligner den lineære klassifiseringen. Du bruker den innebygde estimatoren KernelLinearClassifier. Merk at du legger til kjernekartleggingen som er definert tidligere og endrer modellkatalogen.
### 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'}
Trinn D) Tren modellen
Nå som Kernel-klassifisereren er bygget, er du klar til å trene den. Du velger å iterere 2000 ganger modellen
### 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>]}})
Trinn E) Evaluer modellen
Sist, men ikke minst, evaluerer du ytelsen til modellen din. Du bør være i stand til å slå den logistiske regresjonen.
# 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
Den endelige nøyaktigheten er 84 %, det er en forbedring på 2 % sammenlignet med den logistiske regresjonen. Det er en avveining mellom forbedret nøyaktighet og beregningskostnad. Du må tenke på om 2 % forbedring er verdt tiden som brukes av den forskjellige klassifisereren, og om det har en overbevisende innvirkning på virksomheten din.
Oppsummering
En kjerne er et flott verktøy for å transformere ikke-lineære data til (nesten) lineære. Ulempen med denne metoden er at den er beregningsmessig tidkrevende og kostbar.
Nedenfor finner du den viktigste koden for å trene en kjerneklassifiserer
Angi kjernefunksjonen med høy dimensjon
- 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')
Still inn L2-hyperparameteren
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Bygg modellen
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2, optimizer=optimizer, kernel_mappers=kernel_mappers, model_dir="kernel_train")
Tren modellen
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
Evaluer modellen
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)