Hạt nhân Gaussian trong học máy: Python Phương thức hạt nhân

Mục đích của hướng dẫn này là làm cho một tập dữ liệu có thể phân tách tuyến tính. Hướng dẫn được chia thành hai phần:

Chuyển đổi tính năng
Huấn luyện trình phân loại hạt nhân với Tensorflow

Trong phần đầu tiên, bạn sẽ hiểu ý tưởng đằng sau phương pháp Kernel trong Machine Learning trong khi ở phần thứ hai, bạn sẽ thấy cách đào tạo bộ phân loại kernel bằng Tensorflow. Bạn sẽ sử dụng tập dữ liệu người lớn. Mục tiêu của tập dữ liệu này là phân loại doanh thu dưới và trên 50k, biết được hành vi của từng hộ gia đình.

Tại sao bạn cần Phương thức hạt nhân?

Mục đích của mọi phân loại là dự đoán các lớp một cách chính xác. Vì vậy, tập dữ liệu phải được phân tách. Nhìn vào cốt truyện bên dưới; khá đơn giản để thấy rằng tất cả các điểm phía trên đường màu đen thuộc về lớp thứ nhất và các điểm khác thuộc lớp thứ hai. Tuy nhiên, rất hiếm khi có một tập dữ liệu đơn giản như vậy. Trong hầu hết các trường hợp, dữ liệu không thể tách rời được. Các phương pháp hạt nhân trong Machine Learning gây khó khăn cho các bộ phân loại ngây thơ như hồi quy logistic.

import numpy as np
  import matplotlib.pyplot as plt
  from mpl_toolkits.mplot3d import Axes3D

  x_lin = np.array([1,2,3,4,5,6,7,8,9,10])
  y_lin = np.array([2,2,3,2,2,9,6,8,8,9])
  label_lin = np.array([0,0,0,0,0,1,1,1,1,1])
  
  fig = plt.figure()
  ax=fig.add_subplot(111)
  plt.scatter(x_lin, y_lin, c=label_lin, s=60)
  plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2)
  ax.set_xlim([-5,15])
  ax.set_ylim([-5,15])plt.show()

Trong hình bên dưới, chúng tôi vẽ một tập dữ liệu không thể phân tách tuyến tính. Nếu vẽ một đường thẳng thì hầu hết các điểm sẽ không được xếp vào đúng lớp.

Một cách để giải quyết vấn đề này là lấy tập dữ liệu và chuyển đổi dữ liệu sang một bản đồ đặc trưng khác. Điều đó có nghĩa là bạn sẽ sử dụng một hàm để chuyển đổi dữ liệu trong một gói khác, dữ liệu này có thể tuyến tính được.

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

Dữ liệu từ hình trên nằm trong sơ đồ Hạt nhân Gaussian 2D không thể tách rời. Bạn có thể thử chuyển đổi những dữ liệu này theo không gian ba chiều, nghĩa là bạn tạo một hình có 3 trục.

Trong ví dụ về Hạt nhân Gaussian, chúng tôi sẽ áp dụng ánh xạ đa thức để đưa dữ liệu của mình sang kích thước 3D. Công thức chuyển đổi dữ liệu như sau.

Bạn xác định một hàm trong Gaussian Kernel Python để tạo các bản đồ tính năng mới

Bạn có thể sử dụng cục mịch để mã hóa công thức trên:

Công thức	Mã Numpy tương đương
x	x[:,0]**
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	x[:,1]**2

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

Ánh xạ mới phải có 3 chiều với 16 điểm

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Hãy tạo một đồ thị mới với 3 trục x, y và z tương ứng.

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

Chúng tôi nhận thấy sự cải thiện nhưng nếu chúng tôi thay đổi hướng của biểu đồ thì rõ ràng là tập dữ liệu hiện có thể tách rời được

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

Để thao tác với một tập dữ liệu lớn và có thể phải tạo nhiều hơn 2 chiều, bạn sẽ gặp phải một vấn đề lớn khi sử dụng phương pháp trên. Trên thực tế, bạn cần chuyển đổi tất cả các điểm dữ liệu, điều này rõ ràng là không bền vững. Bạn sẽ mất nhiều thời gian và máy tính của bạn có thể hết bộ nhớ.

Cách phổ biến nhất để khắc phục vấn đề này là sử dụng hạt nhân.

Hạt nhân trong học máy là gì?

Ý tưởng là sử dụng không gian đặc trưng có chiều cao hơn để làm cho dữ liệu gần như có thể phân tách tuyến tính như trong hình trên.

Có rất nhiều không gian có chiều cao hơn để làm cho các điểm dữ liệu có thể phân tách được. Ví dụ: chúng tôi đã chỉ ra rằng ánh xạ đa thức là một khởi đầu tuyệt vời.

Chúng tôi cũng đã chứng minh rằng với nhiều dữ liệu, việc chuyển đổi này không hiệu quả. Thay vào đó, bạn có thể sử dụng hàm Kernel trong Machine Learning để sửa đổi dữ liệu mà không cần thay đổi sang gói tính năng mới.

Điều kỳ diệu của hạt nhân là tìm ra một hàm tránh được mọi rắc rối do tính toán nhiều chiều gây ra. Kết quả của kernel là vô hướng, hay nói cách khác ta quay lại không gian một chiều

Sau khi tìm thấy hàm này, bạn có thể cắm nó vào bộ phân loại tuyến tính tiêu chuẩn.

Hãy xem một ví dụ để hiểu khái niệm về Kernel Machine Learning. Bạn có hai vectơ, x1 và x2. Mục tiêu là tạo ra một chiều cao hơn bằng cách sử dụng ánh xạ đa thức. Đầu ra bằng sản phẩm chấm của bản đồ tính năng mới. Từ phương pháp trên, bạn cần:

Biến x1 và x2 thành một chiều mới
Tính tích số chấm: chung cho tất cả các hạt nhân
Biến x1 và x2 thành một chiều mới

Bạn có thể sử dụng hàm được tạo ở trên để tính kích thước cao hơn.

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

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

Đầu ra

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

Tính tích chấm

Bạn có thể sử dụng dấu chấm đối tượng từ numpy để tính tích số chấm giữa vectơ thứ nhất và vectơ thứ hai được lưu trữ trong x_1.

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

Đầu ra là 8100. Bạn thấy có vấn đề, bạn cần lưu vào bộ nhớ một bản đồ đặc trưng mới để tính tích chấm. Nếu bạn có một tập dữ liệu với hàng triệu bản ghi thì nó sẽ không hiệu quả về mặt tính toán.

Thay vào đó, bạn có thể sử dụng nhân đa thức để tính tích số chấm mà không làm biến đổi vectơ. Hàm này tính tích vô hướng của x1 và x2 như thể hai vectơ này đã được chuyển đổi sang chiều cao hơn. Nói cách khác, hàm hạt nhân tính toán kết quả của tích số chấm từ một không gian đặc trưng khác.

Bạn có thể viết hàm hạt nhân đa thức trong Python như sau.

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

Đó là lũy thừa của tích vô hướng của hai vectơ. Dưới đây, bạn trả về bậc hai của hạt nhân đa thức. Đầu ra bằng với phương pháp khác. Đây là sự kỳ diệu của hạt nhân.

polynomial_kernel(x1, x2, p=2)			
8100

Các loại phương thức hạt nhân

Có rất nhiều kỹ thuật hạt nhân khác nhau có sẵn. Đơn giản nhất là hạt nhân tuyến tính. Chức năng này hoạt động khá tốt cho việc phân loại văn bản. Hạt nhân khác là:

nhân đa thức
Hạt nhân Gaussian

Trong ví dụ với TensorFlow, chúng ta sẽ sử dụng Fourier ngẫu nhiên. TensorFlow có một công cụ ước tính tích hợp để tính toán không gian tính năng mới. Hàm lọc Gaussian là một hàm gần đúng của hàm nhân Gaussian.

Hàm lọc Gaussian tính toán độ tương tự giữa các điểm dữ liệu trong không gian có chiều cao hơn nhiều.

Đào tạo trình phân loại hạt nhân Gaussian với TensorFlow

Mục tiêu của thuật toán là phân loại hộ gia đình có thu nhập nhiều hơn hoặc ít hơn 50 nghìn.

Bạn sẽ đánh giá Máy học hồi quy hạt nhân logistic để có mô hình chuẩn. Sau đó, bạn sẽ huấn luyện bộ phân loại hạt nhân để xem liệu bạn có thể nhận được kết quả tốt hơn hay không.

Bạn sử dụng các biến sau từ tập dữ liệu người lớn:

tuổi
lớp học nghề
fnlwgt
giáo dục
giáo dục_num
hôn nhân
nghề nghiệp
mối quan hệ
cuộc đua
quan hệ tình dục
tăng vốn
vốn_lỗ
giờ_tuần
quê hương
nhãn

Bạn sẽ tiến hành như sau trước khi huấn luyện và đánh giá mô hình:

Bước 1) Nhập thư viện
Bước 2) Nhập dữ liệu
Bước 3) Chuẩn bị dữ liệu
Bước 4) Xây dựng input_fn
Bước 5) Xây dựng mô hình logistic: Mô hình cơ sở
Bước 6) Đánh giá mô hình
Bước 7) Xây dựng bộ phân loại hạt nhân
Bước 8) Đánh giá bộ phân loại hạt nhân

Bước 1) Nhập các thư viện

Để nhập và huấn luyện các mô hình Kernel trong Trí tuệ nhân tạo, bạn cần nhập tensorflow, gấu trúc và uể oải

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Bước 2) Nhập dữ liệu

Bạn tải dữ liệu từ các nguồn sau trang mạng và bạn nhập nó dưới dạng khung dữ liệu gấu trúc.

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

Bây giờ tập huấn luyện và tập kiểm tra đã được xác định, bạn có thể thay đổi nhãn cột từ chuỗi thành số nguyên. tensorflow không chấp nhận giá trị chuỗi cho nhãn.

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)

Bước 3) Chuẩn bị dữ liệu

Tập dữ liệu chứa cả các tính năng liên tục và phân loại. Một cách thực hành tốt là chuẩn hóa các giá trị của các biến liên tục. Bạn có thể sử dụng hàm StandardScaler từ sci-kit learn. Bạn cũng tạo một hàm do người dùng xác định để giúp chuyển đổi tập huấn luyện và tập kiểm tra dễ dàng hơn. Lưu ý rằng, bạn ghép các biến liên tục và biến phân loại thành một tập dữ liệu chung và mảng phải có kiểu: 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

Hàm biến áp đã sẵn sàng, bạn có thể chuyển đổi tập dữ liệu và tạo hàm 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)

Trong bước tiếp theo, bạn sẽ huấn luyện hồi quy logistic. Nó sẽ cung cấp cho bạn độ chính xác cơ bản. Mục tiêu là vượt qua đường cơ sở bằng một thuật toán khác, cụ thể là bộ phân loại hạt nhân.

Bước 4) Xây dựng mô hình logistic: Mô hình cơ sở

Bạn xây dựng cột tính năng với đối tượng real_valued_column. Nó sẽ đảm bảo tất cả các biến đều là dữ liệu số dày đặc.

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

Công cụ ước tính được xác định bằng Công cụ ước tính TensorFlow, bạn hướng dẫn các cột tính năng và nơi lưu biểu đồ.

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}

Bạn sẽ huấn luyện hồi quy logisitc bằng cách sử dụng các lô nhỏ có kích thước 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)

Bạn có thể huấn luyện mô hình với 1.000 lần lặp

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>

Bước 6) Đánh giá mô hình

Bạn xác định công cụ ước tính gọn gàng để đánh giá mô hình. Bạn sử dụng toàn bộ tập dữ liệu để đánh giá

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

Bạn có độ chính xác là 82 phần trăm. Trong phần tiếp theo, bạn sẽ cố gắng đánh bại bộ phân loại logistic bằng bộ phân loại Kernel

Bước 7) Xây dựng bộ phân loại hạt nhân

Công cụ ước tính hạt nhân không quá khác biệt so với công cụ phân loại tuyến tính truyền thống, ít nhất là về mặt xây dựng. Ý tưởng đằng sau là sử dụng sức mạnh của kernel rõ ràng với bộ phân loại tuyến tính.

Bạn cần hai công cụ ước tính được xác định trước có sẵn trong TensorFlow để huấn luyện Trình phân loại hạt nhân:

RandomFourierTính năngMapper
KernelPhân loại tuyến tính

Bạn đã học trong phần đầu tiên rằng bạn cần chuyển đổi chiều thấp thành chiều cao bằng cách sử dụng hàm kernel. Chính xác hơn, bạn sẽ sử dụng Random Fourier, một hàm gần đúng của hàm Gaussian. May mắn thay, Tensorflow có chức năng trong thư viện của nó: RandomFourierFeatureMapper. Mô hình có thể được huấn luyện bằng cách sử dụng công cụ ước tính KernelLinearClassifier.

Để xây dựng mô hình, bạn sẽ làm theo các bước sau:

Đặt chức năng hạt nhân kích thước cao
Đặt siêu tham số L2
Xây dựng mô hình
Đào tạo mô hình
Đánh giá mô hình

Bước A) Đặt chức năng hạt nhân kích thước cao

Tập dữ liệu hiện tại chứa 14 tính năng mà bạn sẽ chuyển đổi sang chiều cao mới của vectơ 5.000 chiều. Bạn sử dụng các tính năng Fourier ngẫu nhiên để đạt được sự chuyển đổi. Nếu bạn nhớ lại công thức Hạt nhân Gaussian, bạn lưu ý rằng có tham số độ lệch chuẩn cần xác định. Tham số này kiểm soát thước đo độ tương tự được sử dụng trong quá trình phân loại.

Bạn có thể điều chỉnh tất cả các tham số trong RandomFourierFeatureMapper bằng:

đầu vào_dim = 14
đầu ra_dim= 5000
stddev=4

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

Bạn cần xây dựng trình ánh xạ kernel bằng cách sử dụng các cột tính năng được tạo trước đó: feat_column

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

Bước B) Đặt siêu tham số L2

Để ngăn chặn việc trang bị quá mức, bạn xử phạt hàm mất mát bằng bộ điều chỉnh L2. Bạn đặt siêu tham số L2 thành 0.1 và tốc độ học thành 5

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

Bước C) Xây dựng mô hình

Bước tiếp theo tương tự như phân loại tuyến tính. Bạn sử dụng công cụ ước tính tích hợp sẵn KernelLinearClassifier. Lưu ý rằng bạn thêm trình ánh xạ hạt nhân được xác định trước đó và thay đổi thư mục mô hình.

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

Bước D) Đào tạo mô hình

Bây giờ bộ phân loại hạt nhân đã được xây dựng, bạn đã sẵn sàng huấn luyện nó. Bạn chọn lặp lại 2000 lần mô hình

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

Bước E) Đánh giá mô hình

Cuối cùng nhưng không kém phần quan trọng, bạn đánh giá hiệu suất của mô hình của mình. Bạn sẽ có thể đánh bại hồi quy logistic.

# 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

Độ chính xác cuối cùng là 84%, cải thiện 2% so với hồi quy logistic. Có sự cân bằng giữa việc cải thiện độ chính xác và chi phí tính toán. Bạn cần suy nghĩ xem liệu mức cải thiện 2% có xứng đáng với thời gian mà bộ phân loại khác đã bỏ ra hay không và liệu nó có tác động thuyết phục đến doanh nghiệp của bạn hay không.

Tổng kết

Hạt nhân là một công cụ tuyệt vời để chuyển đổi dữ liệu phi tuyến tính thành (gần như) tuyến tính. Nhược điểm của phương pháp này là tốn thời gian và chi phí tính toán.

Dưới đây, bạn có thể tìm thấy mã quan trọng nhất để huấn luyện trình phân loại hạt nhân

Đặt chức năng hạt nhân kích thước cao

đầu vào_dim = 14
đầu ra_dim= 5000
stddev=4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Đặt siêu tham số L2

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

Xây dựng mô hình

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

Đào tạo mô hình

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

Đánh giá mô hình

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

Bạn có thể thích:

Tại sao bạn cần Phương thức hạt nhân?

NHỮNG BÀI VIẾT LIÊN QUAN

Hạt nhân trong học máy là gì?

Các loại phương thức hạt nhân

Đào tạo trình phân loại hạt nhân Gaussian với TensorFlow

Tổng kết