Kernel Gaussian trong Học máy: Ví dụ về các phương thức Kernel

Mục lục:

Anonim

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 một cách tuyến tính. Hướng dẫn được chia thành hai phần:

  1. Chuyển đổi tính năng
  2. Đào tạo bộ 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 một phương thức Kernel trong Học máy trong khi trong phần thứ hai, bạn sẽ thấy cách đào tạo một bộ phân loại hạt nhân với Tensorflow. Bạn sẽ sử dụng tập dữ liệu dành cho 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 50k và trên 50k, biết được hành vi của từng hộ gia đình.

Trong hướng dẫn này, bạn sẽ học-

  • Tại sao bạn cần Kernel Method?
  • Kernel trong học máy là gì?
  • Các loại phương thức hạt nhân
  • Huấn luyện bộ phân loại hạt nhân Gaussian với TensorFlow

Tại sao bạn cần Kernel Method?

Mục đích của mọi bộ 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 tách biệt. 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 trên đường màu đen thuộc loại thứ nhất và các điểm khác thuộc loại thứ hai. Tuy nhiên, rất hiếm khi có một bộ 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 phương thức hạt nhân trong Học máy mang lại cho các bộ phân loại ngây thơ như hồi quy logistic gặp khó khăn.

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

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 chúng ta vẽ một đường thẳng, hầu hết các điểm sẽ không được xếp vào lớp chính xác.

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 trong một bản đồ đối tượng địa lý khác. Nó có nghĩa là, bạn sẽ sử dụng một hàm để chuyển đổi dữ liệu trong một kế hoạch khác, nó phải có dạng tuyến tính.

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ơ đồ 2D Gaussian Kernel không thể tách rời. Bạn có thể cố gắng biế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 của chúng tôi, chúng tôi sẽ áp dụng ánh xạ đa thức để đưa dữ liệu của chúng tôi sang một chiều 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 numpy để viết mã công thức trên:

Công thức Mã Numpy tương đương
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

Á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 âm mưu mới với 3 trục, x, y và z tương ứng.

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

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

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

Để thao tác một tập dữ liệu lớn và bạn có thể phải tạo nhiều hơn 2 thứ nguyên, 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 phải 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 .

Kernel trong học máy là gì?

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

Có rất nhiều không gian 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 bước 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 Học máy để 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 tất cả các rắc rối do tính toán chiều cao ám chỉ. Kết quả của một nhân là một vô hướng, hay nói cách khác là chúng ta quay trở lại không gian một chiều

Sau khi bạn tìm thấy chức năng 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 thứ nguyên cao hơn bằng cách sử dụng một ánh xạ đa thức. Kết quả đầu ra bằng tích số chấm của bản đồ đối tượng địa lý mới. Từ phương pháp trên, bạn cần:

  1. Biến đổi x1 và x2 thành một chiều không gian mới
  2. Tính toán sản phẩm dấu chấm: chung cho tất cả các hạt nhân
  3. Biến đổi x1 và x2 thành một chiều không gian mới

Bạn có thể sử dụng hàm đã tạo ở trên để tính thứ nguyên cao hơn.

## Kernelx1 = 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 toán sản phẩm chấm

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

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

Kết quả đầu ra là 8100. Bạn thấy vấn đề, bạn cần lưu trữ trong bộ nhớ một bản đồ tính năng mới để tính ra sản phẩm chấm. Nếu bạn có một tập dữ liệu với hàng triệu bản ghi, nó 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 cần biến đổi vectơ. Hàm này tính tích số chấm của x1 và x2 như thể hai vectơ này đã được biến đổi thành chiều cao hơn. Nói cách khác, một hàm nhân tính toán các kết quả của sản phẩm chấm từ một không gian đặc trưng khác.

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

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

Nó là lũy thừa của tích số chấm của hai vectơ. Dưới đây, bạn trả về bậc hai của nhân đa thức. Đầu ra bằng với phương pháp khác. Đây là điều 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 Kernel khác nhau. Đơn giản nhất là nhân tuyến tính. Chức năng này hoạt động khá tốt để phân loại văn bản. Kernel 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 bộ lọc Gaussian là một hàm gần đúng của hàm hạt nhân Gaussian.

Chức năng lọc Gaussian tính toán sự giống nhau giữa các điểm dữ liệu trong một không gian chiều cao hơn nhiều.

Huấn luyện bộ 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 50k.

Bạn sẽ đánh giá một Học máy hồi quy hạt nhân hậu cần để có một mô hình điểm chuẩn. Sau đó, bạn sẽ đào tạo một bộ phân loại Kernel để xem liệu bạn có thể đạt đượ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 tác
  • 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
  • tình dục
  • tăng vốn
  • capital_loss
  • giờ_ tuần
  • quê hương
  • nhãn

Bạn sẽ tiến hành như sau trước khi đào tạo 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 thư viện

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

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

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

Bạn tải xuống dữ liệu từ trang web sau và nhập dữ liệu đó dưới dạng khung dữ liệu gấu trúc.

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

Bây giờ tập hợp thử nghiệm và huấn luyện đã đượ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 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 chức năng StandardScaler từ sci-kit learning. Bạn cũng tạo một hàm do người dùng xác định để dễ dàng chuyển đổi tập hợp thử nghiệm và đào tạo. Lưu ý rằng, bạn nối các biến liên tục và biến phân loại vào 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 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

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ẽ đào tạo một hồi quy logistic. Nó sẽ cung cấp cho bạn độ chính xác cơ bản. Mục tiêu là đánh bại đườ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 rằng 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ách sử dụ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': , '_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 modeltrain_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ể đào tạo 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 = 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.

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

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

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

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 trình phân loại hậu cần bằng trình phân loại Hạt nhân

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

Bộ ước lượng hạt nhân không quá khác biệt so với bộ phân loại tuyến tính truyền thống, ít nhất là về mặt cấu trúc. Ý tưởng đằng sau là sử dụng sức mạnh của hạt nhân 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 để đào tạo Kernel Classifier:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Bạn đã học trong phần đầu tiên rằng bạn cần phải chuyển đổi chiều thấp thành chiều cao bằng cách sử dụng một hàm nhân. Chính xác hơn, bạn sẽ sử dụng Random Fourier, là 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 bộ ước lượng KernelLinearClassifier.

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

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

Bước A) Đặt chức năng Kernel kích thước cao

Tập dữ liệu hiện tại chứa 14 đặc điểm mà bạn sẽ chuyển đổi sang một 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 Gaussian Kernel, 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 độ đo tương tự 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 với:

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

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

### Map Kernelkernel_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ử lý 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 là 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 KernelLinearClassifier. Lưu ý rằng bạn thêm trình ánh xạ hạt nhân đã xác định trước đó và thay đổi thư mục mô hình.

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

Bước D) Huấn luyện mô hình

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

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

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 bạn. 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 
 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

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

Tóm lược

Kernel là một công cụ tuyệt vời để biến đổi dữ liệu phi tuyến tính thành (gần như) tuyến tính. Điểm thiếu sót của phương pháp này là tốn nhiều 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 để đào tạo trình phân loại hạt nhân

Đặt chức năng Kernel kích thước cao

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

Đặ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)