Kernel gaussiano nell'apprendimento automatico: Python Metodi del kernel
Evelyn Clarke
Lo scopo di questo tutorial è rendere un set di dati linearmente separabile. Il tutorial è diviso in due parti:
- Trasformazione delle caratteristiche
- Addestra un classificatore kernel con Tensorflow
Nella prima parte, comprenderai l'idea alla base di un metodo Kernel in Machine Learning, mentre nella seconda parte, vedrai come addestrare un classificatore kernel con Tensorflow. Utilizzerai il dataset per adulti. L'obiettivo di questo dataset è classificare le entrate al di sotto e al di sopra di 50k, conoscendo il comportamento di ogni nucleo familiare.
Perché hai bisogno dei metodi 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 kernel nell'apprendimento automatico danno difficoltà ai classificatori ingenui come una regressione logistica.
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()
Nella figura seguente, tracciamo un set di dati che non è linearmente separabile. Se tracciamo una linea retta, la maggior parte dei punti non verranno classificati 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 lineare.
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 si trovano in un piano del kernel gaussiano 2D che non è separabile. Puoi provare a trasformare questi dati in una dimensione tridimensionale, 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 nel kernel gaussiano Python per creare le nuove mappe delle caratteristiche
Puoi usare numpy per codificare la formula sopra:
| Formula | Codice Numpy equivalente |
|---|---|
| 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
La nuova mappatura dovrebbe essere a 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.
# 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()
Notiamo un miglioramento ma se cambiamo l'orientamento del grafico, è chiaro che il set di dati è ora separabile
# 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()
Per manipolare un set di dati di grandi dimensioni e potresti dover creare più di 2 dimensioni, dovrai affrontare un grosso problema utilizzando il metodo sopra descritto. In effetti, è necessario trasformare tutti i 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 a Kernel.
Cos'è un kernel nell'apprendimento automatico?
L'idea è quella di utilizzare uno spazio di caratteristiche di dimensione superiore per rendere i dati quasi linearmente separabili come mostrato nella figura sopra.
Esistono 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 kernel in Machine Learning per modificare i dati senza passare a un nuovo piano di funzionalità.
La magia del kernel sta nel 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 scalare della nuova mappa delle caratteristiche. Dal metodo sopra, è necessario:
- Trasforma x1 e x2 in una nuova dimensione
- Calcola il prodotto scalare: comune a tutti i kernel
- Trasforma x1 e x2 in una nuova dimensione
È possibile utilizzare la funzione creata sopra per calcolare la dimensione superiore.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Uscita
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Calcola il prodotto scalare
È possibile 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. Vedete il problema, è necessario archiviare in memoria una nuova mappa delle caratteristiche per calcolare il prodotto scalare. Se disponi di un set di dati con milioni di record, è computazionalmente inefficace.
Invece, puoi usare il nucleo 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 diversamente, una funzione del kernel calcola i risultati del prodotto scalare da un altro spazio di caratteristiche.
È possibile scrivere la funzione del kernel polinomiale 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 viene restituito 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 Kernel. Il più semplice è il kernel lineare. Questa funzione funziona abbastanza bene per la classificazione del testo. L'altro kernel è:
- Nucleo polinomiale
- Kernel gaussiano
Nell'esempio con TensorFlow, utilizzeremo il Fourier casuale. TensorFlow dispone di uno stimatore integrato per calcolare il nuovo spazio di funzionalità. La funzione del filtro gaussiano è un'approssimazione della funzione del kernel gaussiano.
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 il reddito familiare superiore o inferiore a 50.
Valuterai un Machine Learning di regressione logistica del kernel per avere un modello di riferimento. Successivamente, addestrerai un classificatore kernel per vedere se riesci a ottenere risultati migliori.
Si utilizzano le seguenti variabili dal set di dati degli adulti:
- classe operaia
- fnlwgt
- continua
- numero_istruzione
- coniugale
- occupazione
- rapporto
- gara
- sesso
- plusvalenza
- perdita_capitale
- ore_settimana
- Paese d'origine
- etichetta
Procederai 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 input_fn
- Passaggio 5) Costruire il modello logistico: modello di base
- Passaggio 6) Valutare il modello
- Passaggio 7) Costruisci il classificatore Kernel
- Passaggio 8) Valutare il classificatore del kernel
Passo 1) Importa le librerie
Per importare e addestrare i modelli kernel Intelligenza Artificiale, devi importare tensorflow, panda e insensibile
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Passo 2) Importa i dati
Puoi scaricare i dati da quanto segue sito web ufficiale e lo importi come dataframe panda.
## 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)
Ora che il treno e il set di test sono definiti, puoi modificare l'etichetta della colonna da stringa a intero. tensorflow non accetta il valore 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)
Passo 3) Prepara i dati
Il set di dati contiene sia funzionalità continue che categoriali. Una buona pratica è standardizzare i valori delle variabili continue. Puoi utilizzare la funzione StandardScaler da sci-kit learn. Si crea anche una funzione definita dall'utente per semplificare la conversione del set di training e test. Tieni presente che concateni le variabili continue e categoriali in 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 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
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)
Nel passaggio successivo, addestrerai una regressione logistica. Ti darà una precisione di base. L'obiettivo è superare la linea di base con un algoritmo diverso, ovvero un classificatore Kernel.
Passo 4) Costruire il modello logistico: modello di base
Costruisci la colonna delle funzionalità 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, tu indica 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': <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}
Addestrerai la regressione logistica utilizzando mini-batch di dimensione 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)
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 = 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>
Passo 6) Valuta il modello
Si definisce lo stimatore numpy per valutare il modello. Utilizzi l'intero set di dati per la valutazione
# 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}
Hai una precisione dell'82%. Nella prossima sezione proverai a superare il classificatore logistico con un classificatore Kernel
Passo 7) Costruisci il classificatore Kernel
Lo stimatore kernel non è molto diverso dal tradizionale classificatore lineare, 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
Nella prima sezione hai imparato che devi trasformare la dimensione bassa in una dimensione alta utilizzando una funzione kernel. Più precisamente, utilizzerai il Fourier casuale, 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:
- Imposta la funzione Kernel ad alta dimensione
- Imposta l'iperparametro L2
- Costruisci il modello
- Allena il modello
- Valuta il modello
Passaggio A) Imposta la funzione Kernel ad alta dimensione
Il set di dati attuale contiene 14 caratteristiche che trasformerai in una nuova dimensione elevata del vettore a 5.000 dimensioni. Utilizzi le funzionalità 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 utilizzata durante la classificazione.
Puoi ottimizzare tutti i parametri in RandomFourierFeatureMapper con:
- ingresso_dim = 14
- dim_uscita= 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
È necessario costruire il mappatore del kernel utilizzando le colonne delle funzionalità create prima: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Passaggio B) Imposta l'iperparametro L2
Per evitare un overfitting, si penalizza la funzione di perdita con il regolarizzatore L2. 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. Tieni presente che aggiungi il mappatore del kernel definito in precedenza e modifichi la directory del modello.
### 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'}
Passaggio D) Allena il modello
Ora che il classificatore Kernel è stato creato, sei pronto per addestrarlo. Scegli di ripetere 2000 volte il modello
### 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>]}})
Passaggio E) Valuta il modello
Ultimo ma non meno importante, valuti le prestazioni del tuo modello. Dovresti essere in grado di sconfiggere la regressione logistica.
# 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
La precisione finale è dell'84%, ovvero un miglioramento del 2% rispetto alla regressione logistica. Esiste un compromesso tra miglioramento della precisione e costo computazionale. Devi pensare se un 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 dati non lineari in (quasi) lineari. Lo svantaggio di questo metodo è che richiede molto tempo ed è costoso dal punto di vista computazionale.
Di seguito puoi trovare il codice più importante per addestrare un classificatore del kernel
Imposta la funzione Kernel ad alta dimensione
- ingresso_dim = 14
- dim_uscita= 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")
Allena 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)
