Kernel gaussiano nell'apprendimento automatico: esempi di metodi del kernel

Sommario:

Anonim

Lo scopo di questo tutorial è rendere un set di dati separabile linearmente. Il tutorial è diviso in due parti:

  1. Trasformazione delle caratteristiche
  2. Addestra un classificatore del kernel con Tensorflow

Nella prima parte, capirai l'idea alla base di un metodo Kernel in Machine Learning mentre nella seconda parte, vedrai come addestrare un classificatore del kernel con Tensorflow. Utilizzerai il set di dati per adulti. L'obiettivo di questo set di dati è classificare le entrate al di sotto e al di sopra di 50k, conoscendo il comportamento di ciascuna famiglia.

In questo tutorial imparerai-

  • Perché hai bisogno dei metodi del kernel?
  • Cos'è un kernel nell'apprendimento automatico?
  • Tipi di metodi del kernel
  • Addestra il classificatore del kernel gaussiano con TensorFlow

Perché hai bisogno dei metodi del kernel?

Lo scopo di ogni classificatore è prevedere correttamente le classi. Per questo, il set di dati dovrebbe essere separabile. Guarda la trama qui sotto; è abbastanza semplice vedere che tutti i punti sopra la linea nera appartengono alla prima classe e gli altri punti alla seconda classe. Tuttavia, è estremamente raro avere un set di dati così semplice. Nella maggior parte dei casi, i dati non sono separabili. I metodi del kernel in Machine Learning danno a classificatori ingenui come una regressione logistica un momento difficile.

import numpy as npimport matplotlib.pyplot as pltfrom 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()

Nella figura seguente, tracciamo un set di dati che non è separabile linearmente. Se tracciamo una linea retta, la maggior parte dei punti non sarà classificata nella classe corretta.

Un modo per affrontare questo problema è prendere il set di dati e trasformare i dati in un'altra mappa delle caratteristiche. Significa che utilizzerai una funzione per trasformare i dati in un altro piano, che dovrebbe essere trasferibile.

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

I dati della figura sopra sono in un piano del kernel gaussiano 2D che non è separabile. Puoi provare a trasformare questi dati in una tridimensionalità, significa creare una figura con 3 assi.

Nel nostro esempio del kernel gaussiano, applicheremo una mappatura polinomiale per portare i nostri dati in una dimensione 3D. La formula per trasformare i dati è la seguente.

Si definisce una funzione in Gaussian Kernel Python per creare le nuove mappe di caratteristiche

Puoi usare numpy per codificare la formula sopra:

Formula Codice Numpy equivalente
X x [:, 0] **
y x [:, 1]
x 2 x [:, 0] ** 2
np.sqrt (2) *
xy x [:, 0] * x [:, 1]
y 2 x [:, 1] ** 2 
### illustration purposedef mapping(x, y):x = np.c_[(x, y)]if len(x) > 2:x_1 = x[:,0]**2x_2 = np.sqrt(2)*x[:,0]*x[:,1]x_3 = x[:,1]**2else:x_1 = x[0]**2x_2 = np.sqrt(2)*x[0]*x[1]x_3 = x[1]**2trans_x = np.array([x_1, x_2, x_3])return trans_x

La nuova mappatura dovrebbe essere di 3 dimensioni con 16 punti

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

Creiamo un nuovo grafico con 3 assi, x, yez rispettivamente.

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

Vediamo un miglioramento ma se cambiamo l'orientamento del grafico, è chiaro che il set di dati è ora separabile

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

Per manipolare un set di dati di grandi dimensioni e potresti dover creare più di 2 dimensioni, dovrai affrontare un grosso problema usando il metodo sopra. In effetti, è necessario trasformare tutti i punti dati, il che chiaramente non è sostenibile. Ci vorranno anni e il tuo computer potrebbe esaurire la memoria.

Il modo più comune per superare questo problema è utilizzare un kernel .

Cos'è un kernel nell'apprendimento automatico?

L'idea è di utilizzare uno spazio per le caratteristiche di dimensioni maggiori per rendere i dati separabili in modo quasi lineare, come mostrato nella figura sopra.

Ci sono molti spazi dimensionali superiori per rendere separabili i punti dati. Ad esempio, abbiamo dimostrato che la mappatura polinomiale è un ottimo inizio.

Abbiamo anche dimostrato che con molti dati, queste trasformazioni non sono efficienti. È invece possibile utilizzare una funzione del kernel in Machine Learning per modificare i dati senza passare a un nuovo piano di funzionalità.

La magia del kernel è trovare una funzione che eviti tutti i problemi implicati dal calcolo ad alta dimensione. Il risultato di un kernel è uno scalare, o detto diversamente siamo tornati allo spazio unidimensionale

Dopo aver trovato questa funzione, puoi collegarla al classificatore lineare standard.

Vediamo un esempio per comprendere il concetto di Kernel Machine Learning. Hai due vettori, x1 e x2. L'obiettivo è creare una dimensione superiore utilizzando una mappatura polinomiale. L'output è uguale al prodotto in punti della nuova mappa delle caratteristiche. Dal metodo sopra, devi:

  1. Trasforma x1 e x2 in una nuova dimensione
  2. Calcola il prodotto scalare: comune a tutti i kernel
  3. Trasforma x1 e x2 in una nuova dimensione

È possibile utilizzare la funzione creata sopra per calcolare la dimensione superiore.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1)

Produzione

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

Calcola il prodotto scalare

Puoi utilizzare l'oggetto punto da numpy per calcolare il prodotto scalare tra il primo e il secondo vettore memorizzato in x_1.

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

L'output è 8100. Se vedi il problema, devi salvare in memoria una nuova mappa delle caratteristiche per calcolare il prodotto scalare. Se si dispone di un set di dati con milioni di record, è computazionalmente inefficace.

Invece, puoi usare il kernel polinomiale per calcolare il prodotto scalare senza trasformare il vettore. Questa funzione calcola il prodotto scalare di x1 e x2 come se questi due vettori fossero stati trasformati nella dimensione superiore. Detto in modo diverso, una funzione del kernel calcola i risultati del prodotto scalare da un altro spazio di funzionalità.

Puoi scrivere la funzione kernel polinomiale in Python come segue.

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

È la potenza del prodotto scalare di due vettori. Di seguito, restituisci il secondo grado del kernel polinomiale. L'output è uguale all'altro metodo. Questa è la magia del kernel.

polynomial_kernel(x1, x2, p=2)8100

Tipi di metodi del kernel

Sono disponibili molte diverse tecniche del kernel. Il più semplice è il kernel lineare. Questa funzione funziona abbastanza bene per la classificazione del testo. L'altro kernel è:

  • Kernel polinomiale
  • Kernel gaussiano

Nell'esempio con TensorFlow, useremo il Random Fourier. TensorFlow dispone di uno stimatore integrato per calcolare il nuovo spazio delle funzionalità. La funzione di filtro gaussiano è un'approssimazione della funzione kernel gaussiana.

La funzione di filtro gaussiano calcola la somiglianza tra i punti dati in uno spazio dimensionale molto più elevato.

Addestra il classificatore del kernel gaussiano con TensorFlow

L'obiettivo dell'algoritmo è classificare la famiglia che guadagna più o meno di 50k.

Valuterai un apprendimento automatico della regressione del kernel logistico per avere un modello di benchmark. Dopodiché, addestrerai un classificatore del kernel per vedere se puoi ottenere risultati migliori.

Utilizzi le seguenti variabili dal set di dati per adulti:

  • età
  • classe di lavoro
  • fnlwgt
  • formazione scolastica
  • education_num
  • coniugale
  • occupazione
  • relazione
  • gara
  • sesso
  • plusvalenza
  • capital_loss
  • ore_settimana
  • Paese d'origine
  • etichetta

Procedi come segue prima di addestrare e valutare il modello:

  • Passaggio 1) Importa le librerie
  • Passaggio 2) Importa i dati
  • Passaggio 3) Preparare i dati
  • Passaggio 4) Costruisci il file input_fn
  • Passaggio 5) Costruisci il modello logistico: modello di base
  • Passaggio 6) Valuta il modello
  • Passaggio 7) Costruisci il classificatore del kernel
  • Passaggio 8) Valuta il classificatore del kernel

Passaggio 1) Importa le librerie

Per importare e addestrare i modelli del kernel nell'intelligenza artificiale, è necessario importare tensorflow, panda e numpy

#import numpy as npfrom sklearn.model_selectionimport train_test_splitimport tensorflow as tfimport pandas as pdimport numpy as np

Passaggio 2) Importa i dati

Scarichi i dati dal seguente sito Web e li importi come dataframe panda.

## Define path dataCOLUMNS = ['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"## Importdf_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)

Ora che il training e il set di test sono definiti, è possibile modificare l'etichetta della colonna da stringa a numero intero. tensorflow non accetta valori stringa per l'etichetta.

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)

Passaggio 3) Preparare i dati

Il set di dati contiene caratteristiche sia continue che categoriali. Una buona pratica è standardizzare i valori delle variabili continue. È possibile utilizzare la funzione StandardScaler da sci-kit learn. Si crea anche una funzione definita dall'utente per semplificare la conversione del set di treni e test. Si noti che, si concatenano le variabili continue e categoriali a un set di dati comune e l'array dovrebbe essere del tipo: 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 StandardScalerfrom sklearn import preprocessingdef 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

La funzione trasformatore è pronta, puoi convertire il set di dati e creare la funzione 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)

Nella fase successiva, addestrerai una regressione logistica. Ti darà una precisione di base. L'obiettivo è battere la linea di base con un algoritmo diverso, vale a dire un classificatore del kernel.

Passaggio 4) Costruisci il modello logistico: modello di base

Si costruisce la colonna delle caratteristiche con l'oggetto real_valued_column. Si assicurerà che tutte le variabili siano dati numerici densi.

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

Lo stimatore viene definito utilizzando TensorFlow Estimator, istruisci le colonne delle caratteristiche e dove salvare il grafico.

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': , '_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}

Addestrerai la regressione logisitc utilizzando mini-batch di dimensione 200.

# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_train},y=y_train,batch_size=200,num_epochs=None,shuffle=True)

Puoi addestrare il modello con 1.000 iterazioni

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 = 1INFO:tensorflow:global_step/sec: 324.16INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)INFO:tensorflow:global_step/sec: 267.092INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)INFO:tensorflow:global_step/sec: 292.679INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)INFO:tensorflow:global_step/sec: 225.582INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)INFO:tensorflow:global_step/sec: 209.975INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)INFO:tensorflow:global_step/sec: 241.648INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)INFO:tensorflow:global_step/sec: 305.193INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)INFO:tensorflow:global_step/sec: 396.295INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)INFO:tensorflow:global_step/sec: 359.857INFO: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.

Passaggio 6) Valuta il modello

Definisci lo stimatore numpy per valutare il modello. Si utilizza l'intero set di dati per la valutazione

# Evaluationtest_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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000INFO: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:23INFO: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}

Hai una precisione dell'82 percento. Nella sezione successiva, proverai a battere il classificatore logistico con un classificatore del kernel

Passaggio 7) Costruisci il classificatore del kernel

Lo stimatore del kernel non è così diverso dal classificatore lineare tradizionale, almeno in termini di costruzione. L'idea alla base è quella di utilizzare la potenza del kernel esplicito con il classificatore lineare.

Sono necessari due stimatori predefiniti disponibili in TensorFlow per addestrare il classificatore del kernel:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Hai imparato nella prima sezione che devi trasformare la dimensione bassa in una dimensione alta usando una funzione del kernel. Più precisamente, utilizzerai il Random Fourier, che è un'approssimazione della funzione gaussiana. Fortunatamente, Tensorflow ha la funzione nella sua libreria: RandomFourierFeatureMapper. Il modello può essere addestrato utilizzando lo stimatore KernelLinearClassifier.

Per costruire il modello, seguirai questi passaggi:

  1. Imposta la funzione Kernel di alta dimensione
  2. Imposta l'iperparametro L2
  3. Costruisci il modello
  4. Addestra il modello
  5. Valuta il modello

Passaggio A) Impostare la funzione del kernel di dimensioni elevate

L'attuale set di dati contiene 14 caratteristiche che trasformerai in una nuova dimensione alta del vettore a 5.000 dimensioni. Utilizzi le caratteristiche casuali di Fourier per ottenere la trasformazione. Se ricordi la formula del kernel gaussiano, noti che c'è il parametro di deviazione standard da definire. Questo parametro controlla la misura di somiglianza impiegata durante la classificazione.

Puoi regolare tutti i parametri in RandomFourierFeatureMapper con:

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

È necessario costruire il kernel mapper utilizzando le colonne delle funzionalità create prima: feat_column

### Map Kernelkernel_mappers = {feat_column: [kernel_mapper]}

Passaggio B) Impostare l'iperparametro L2

Per evitare l'overfitting, penalizzi la funzione di perdita con il regolarizzatore L2. Si imposta l'iperparametro L2 su 0,1 e la velocità di apprendimento su 5

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

Passaggio C) Costruisci il modello

Il passaggio successivo è simile alla classificazione lineare. Si utilizza lo stimatore integrato KernelLinearClassifier. Notare che si aggiunge il kernel mapper definito in precedenza e si cambia la directory del modello.

### Prep estimatorestimator_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': , '_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'}

Passaggio D) Addestra il modello

Ora che il classificatore del kernel è stato creato, sei pronto per addestrarlo. Scegli di iterare 2000 volte il modello

### estimateestimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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 = 1INFO:tensorflow:global_step/sec: 86.6365INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)INFO:tensorflow:global_step/sec: 80.1986INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)INFO:tensorflow:global_step/sec: 79.6376INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)INFO:tensorflow:global_step/sec: 95.8442INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)INFO:tensorflow:global_step/sec: 93.7799INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)INFO:tensorflow:global_step/sec: 94.7071INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)INFO:tensorflow:global_step/sec: 90.7402INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)INFO:tensorflow:global_step/sec: 94.4924INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)INFO:tensorflow:global_step/sec: 95.3472INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)INFO:tensorflow:global_step/sec: 97.2928INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)INFO:tensorflow:global_step/sec: 85.6761INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)INFO:tensorflow:global_step/sec: 91.4194INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)INFO:tensorflow:global_step/sec: 82.5954INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)INFO:tensorflow:global_step/sec: 89.8748INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)INFO:tensorflow:global_step/sec: 76.9761INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)INFO:tensorflow:global_step/sec: 73.7192INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)INFO:tensorflow:global_step/sec: 83.0573INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)INFO:tensorflow:global_step/sec: 71.7029INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)INFO:tensorflow:global_step/sec: 73.2663INFO: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': , 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': , 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): []}})

Passaggio E) Valuta il modello

Ultimo ma non meno importante, valuti le prestazioni del tuo modello. Dovresti essere in grado di battere la regressione logistica.

# Evaluate and report metrics.eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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:50INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000INFO: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:51INFO: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

La precisione finale è dell'84%, è un miglioramento del 2% rispetto alla regressione logistica. Esiste un compromesso tra il miglioramento della precisione e il costo computazionale. Devi pensare se il miglioramento del 2% vale il tempo impiegato dal diverso classificatore e se ha un impatto convincente sulla tua attività.

Sommario

Un kernel è un ottimo strumento per trasformare i dati non lineari in (quasi) lineari. Il difetto di questo metodo è che richiede tempo e denaro a livello di calcolo.

Di seguito, puoi trovare il codice più importante per addestrare un classificatore del kernel

Imposta la funzione Kernel di alta dimensione

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

Imposta l'iperparametro L2

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

Costruisci il modello

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

Addestra il modello

estimator_kernel.fit(input_fn=train_input_fn, steps=2000)

Valuta il modello

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)