1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ sử dụng Sổ tay trên nền tảng AI để xây dựng và huấn luyện một mô hình giúp xác định các giao dịch gian lận, đồng thời tìm hiểu các thông tin dự đoán của mô hình thông qua SDK AI giải thích. Phát hiện gian lận là một loại tính năng phát hiện hoạt động bất thường dành riêng cho dịch vụ tài chính và đặt ra một số thách thức thú vị cho các mô hình học máy: tập dữ liệu vốn đã không cân bằng và nhu cầu giải thích kết quả của mô hình.
Kiến thức bạn sẽ học được
Bạn sẽ tìm hiểu cách:
- Xử lý các tập dữ liệu không cân bằng
- Xây dựng và đánh giá mô hình phát hiện gian lận bằng tf.keras trong Sổ tay trên nền tảng AI
- Sử dụng SDK AI có thể giải thích ở trong sổ tay để tìm hiểu lý do mô hình này phân loại các giao dịch là gian lận
- Triển khai mô hình cho Nền tảng AI bằng tính năng giải thích, nhận thông tin dự đoán và nội dung giải thích về mô hình đã triển khai
Tổng chi phí để chạy phòng thí nghiệm này trên Google Cloud là khoảng 1 đô la.
2. Tại sao lại phát hiện gian lận?
Tính năng phát hiện hoạt động bất thường có thể là một ứng viên phù hợp cho công nghệ học máy vì thường rất khó để viết một loạt câu lệnh dựa trên quy tắc để xác định các điểm ngoại lai trong dữ liệu. Phát hiện gian lận là một loại tính năng phát hiện hoạt động bất thường và đặt ra hai thách thức thú vị đối với công nghệ học máy:
- Tập dữ liệu rất mất cân bằng: bởi vì các điểm bất thường thường không có quá nhiều. Công nghệ học máy hoạt động hiệu quả nhất khi các tập dữ liệu được cân bằng. Vì vậy, mọi thứ có thể trở nên phức tạp khi các điểm ngoại lai chỉ chiếm chưa đến 1% dữ liệu.
- Cần giải thích kết quả: nếu tìm kiếm hoạt động gian lận thì rất có thể bạn sẽ muốn biết lý do hệ thống gắn cờ nội dung nào đó là gian lận thay vì chỉ nhận lời nói qua. Các công cụ giải thích có thể giúp bạn làm việc này.
3. Thiết lập môi trường
Bạn cần một dự án Google Cloud Platform đã bật tính năng thanh toán để chạy lớp học lập trình này. Để tạo một dự án, hãy làm theo hướng dẫn tại đây.
Bước 1: Bật API mô hình Cloud AI Platform
Chuyển đến phần Mô hình nền tảng AI trên Cloud Console rồi nhấp vào Bật nếu bạn chưa bật.
Bước 2: Bật Compute Engine API
Chuyển đến Compute Engine rồi chọn Enable (Bật) nếu bạn chưa bật tính năng này. Bạn sẽ cần có gói này để tạo thực thể sổ tay.
Bước 3: Tạo một thực thể Sổ tay trên nền tảng AI
Chuyển đến mục Sổ tay trên nền tảng AI trên Cloud Console rồi nhấp vào Phiên bản mới. Sau đó, hãy chọn loại thực thể TensorFlow Enterprise 2.1 không có GPU:
Sử dụng các tuỳ chọn mặc định rồi nhấp vào Tạo. Sau khi tạo phiên bản, hãy chọn Open JupyterLab:
Khi mở thực thể đó, hãy chọn sổ tay Python 3 trong trình chạy:
Bước 4: Nhập các gói Python
Tạo một ô mới rồi nhập các thư viện mà chúng ta sẽ sử dụng trong lớp học lập trình này:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Tải xuống và xử lý dữ liệu
Chúng tôi sẽ sử dụng tập dữ liệu được tạo theo cách tổng hợp này từ Kaggle để huấn luyện mô hình của mình. Tập dữ liệu ban đầu bao gồm 6,3 triệu hàng, 8 nghìn trong số đó là giao dịch gian lận – chỉ chiếm 0,1% toàn bộ tập dữ liệu!
Bước 1: Tải tập dữ liệu Kaggle xuống và đọc bằng Gấu trúc
Chúng tôi đã cung cấp tập dữ liệu Kaggle trong Google Cloud Storage. Bạn có thể tải Gemini xuống bằng cách chạy lệnh gsutil sau trong sổ tay Jupyter của mình:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Tiếp theo, hãy đọc tập dữ liệu này dưới dạng Pandas DataFrame và xem trước tập dữ liệu đó:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Bạn sẽ thấy như sau trong bản xem trước:
Bước 2: Xem xét dữ liệu không cân bằng
Như đã đề cập ở trên, hiện tại tập dữ liệu chứa 99,9% ví dụ không gian lận. Nếu chúng ta huấn luyện một mô hình dựa trên dữ liệu đó, có khả năng mô hình sẽ đạt được độ chính xác 99,9% bằng cách đoán mọi giao dịch không phải là giao dịch gian lận, chỉ đơn giản vì 99,9% dữ liệu là các trường hợp không phải giao dịch gian lận.
Có một vài phương pháp để xử lý dữ liệu không cân bằng. Ở đây, chúng ta sẽ dùng kỹ thuật gọi là giảm tần số lấy mẫu. Giảm tần số lấy mẫu nghĩa là chỉ sử dụng một tỷ lệ nhỏ lớp học chủ yếu trong quá trình huấn luyện. Trong trường hợp này là "không gian lận" là lớp chiếm đa số vì chiếm 99,9% dữ liệu.
Để giảm bớt mẫu tập dữ liệu, chúng tôi sẽ lấy tổng cộng khoảng 8 nghìn ví dụ về gian lận và một mẫu ngẫu nhiên gồm khoảng 31 nghìn trường hợp không gian lận. Bằng cách này, tập dữ liệu thu được sẽ có 25% trường hợp gian lận, so với 0,1% chúng tôi có trước đây.
Trước tiên, chia dữ liệu thành hai DataFrames, một cho gian lận và một cho không gian lận (chúng ta sẽ sử dụng phần này trong lớp học lập trình sau khi triển khai mô hình của mình):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Sau đó, lấy một mẫu ngẫu nhiên các trường hợp không phải gian lận. Chúng tôi đang sử dụng 0,005% vì điều này sẽ giúp chúng tôi phân chia các giao dịch gian lận/không lừa đảo theo tỷ lệ 25 / 75. Bằng cách đó, bạn có thể tập hợp lại dữ liệu và xáo trộn. Để đơn giản hoá quy trình, chúng tôi cũng sẽ xoá một số cột mà chúng tôi sẽ không dùng để huấn luyện:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Bây giờ, chúng ta đã có một tập dữ liệu cân bằng hơn nhiều. Tuy nhiên, nếu chúng ta nhận thấy mô hình của mình hội tụ độ chính xác khoảng 75%, có khả năng cao là mô hình đó sẽ đoán là "không lừa đảo" trong mọi trường hợp.
Bước 3: Chia dữ liệu thành các nhóm huấn luyện và nhóm thử nghiệm
Việc cuối cùng cần làm trước khi xây dựng mô hình là chia tách dữ liệu. Chúng tôi sẽ sử dụng tỷ lệ phân chia thử nghiệm tàu 80/20:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*Đ. A. Lopez-Rojas , A. Elmir và S. Axelsson. "PaySim: Trình mô phỏng tiền trên thiết bị di động tài chính để phát hiện gian lận". Trong: Hội thảo Mô hình và Mô phỏng Châu Âu lần thứ 28-EMSS, Larnaca, Síp. 2016
5. Xây dựng, huấn luyện và đánh giá mô hình tf.keras
Chúng tôi sẽ xây dựng bằng API tf.keras của TensorFlow. Mã mô hình trong mục này được xây dựng dựa trên hướng dẫn này từ các tài liệu TensorFlow. Trước tiên, chúng ta sẽ chuẩn hoá dữ liệu, sau đó xây dựng và huấn luyện mô hình bằng cách sử dụng thông số class_weight để tính đến phần mất cân bằng dữ liệu còn lại.
Bước 1: Chuẩn hoá dữ liệu
Khi huấn luyện một mô hình dựa trên dữ liệu số, bạn cần phải chuẩn hoá dữ liệu, đặc biệt là khi mỗi cột nằm trong một phạm vi khác nhau. Điều này có thể giúp ngăn chặn thiết bị phát nổ trong quá trình tập luyện. Chúng ta có thể chuẩn hoá dữ liệu bằng cách làm như sau:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Sau đó, hãy xem trước dữ liệu đã chuẩn hoá của chúng tôi:
train_set
Bước 2: Xác định trọng số của lớp
Khi giảm tần suất lấy mẫu dữ liệu, chúng tôi vẫn muốn giữ lại một số giao dịch không gian lận để không bị mất thông tin về các giao dịch đó. Đó là lý do chúng tôi không cân bằng hoàn toàn dữ liệu. Vì tập dữ liệu này vẫn chưa cân bằng và chúng tôi quan tâm nhất đến việc xác định chính xác các giao dịch gian lận, nên chúng tôi muốn mô hình của mình phân bổ nhiều trọng số hơn cho các ví dụ gian lận trong tập dữ liệu.
Tham số Keras class_weight cho phép chúng ta chỉ định chính xác trọng số mà chúng ta muốn đưa ra ví dụ cho mỗi lớp, dựa trên tần suất các lớp đó xuất hiện trong tập dữ liệu:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Chúng ta sẽ sử dụng biến này khi huấn luyện mô hình ở bước tiếp theo.
Bước 3: Đào tạo và đánh giá mô hình
Chúng ta sẽ xây dựng mô hình bằng API Mô hình tuần tự Keras, cho phép xác định mô hình dưới dạng một ngăn xếp lớp. Chúng tôi sẽ theo dõi một số chỉ số trong quá trình huấn luyện để nắm được hiệu suất của mô hình ở từng lớp trong tập dữ liệu.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Sau đó, chúng ta sẽ xác định một vài biến toàn cục để sử dụng trong quá trình huấn luyện cùng với một số thông số dừng sớm.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Cuối cùng, chúng ta sẽ gọi hàm đã xác định ở trên để tạo mô hình:
model = make_model()
model.summary()
Chúng ta có thể huấn luyện mô hình bằng phương thức fit(), truyền các tham số được xác định ở trên:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
Quá trình huấn luyện sẽ mất vài phút để chạy.
Bước 4: Trực quan hoá các chỉ số của mô hình
Bây giờ, chúng ta đã có mô hình đã huấn luyện, hãy xem mô hình đó hoạt động như thế nào bằng cách vẽ biểu đồ các chỉ số khác nhau trong suốt thời gian bắt đầu huấn luyện:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
Biểu đồ của bạn sẽ có dạng tương tự như sau (nhưng sẽ không hoàn toàn giống nhau):
Bước 5: In ma trận nhầm lẫn
Ma trận nhầm lẫn là một cách hay để trực quan hoá hiệu suất của mô hình trên tập dữ liệu kiểm thử. Đối với mỗi lớp, báo cáo này sẽ cho chúng tôi biết tỷ lệ phần trăm số ví dụ kiểm thử mà mô hình của chúng tôi dự đoán đúng và không chính xác. Scikit Learn có một số tiện ích để tạo và vẽ đồ thị ma trận nhầm lẫn mà chúng ta sẽ sử dụng ở đây.
Ở phần đầu của sổ tay, chúng ta đã nhập tiện ích confusion_matrix. Để sử dụng công cụ này, trước tiên, chúng ta sẽ tạo một danh sách các dự đoán cho mô hình của mình. Ở đây, chúng ta sẽ làm tròn các giá trị được trả về từ mô hình để danh sách này khớp với danh sách nhãn thực tế cơ bản:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Bây giờ, chúng ta đã sẵn sàng đưa dữ liệu này vào phương thức confusion_matrix, cùng với các nhãn thông tin thực tế:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Điều này cho chúng tôi thấy số lượng tuyệt đối các dự đoán chính xác và không chính xác của mô hình trong tập hợp kiểm định. Số ở trên cùng bên trái cho biết số lượng ví dụ từ tập hợp thử nghiệm của chúng tôi, mô hình của chúng tôi được dự đoán chính xác là không gian lận. Con số ở dưới cùng bên phải cho biết số lượt hiển thị được dự đoán chính xác là gian lận (chúng tôi quan tâm nhiều nhất đến con số này). Bạn có thể thấy rằng công cụ này dự đoán chính xác phần lớn các mẫu cho mỗi lớp.
Để dễ hình dung hơn, chúng tôi đã điều chỉnh hàm plot_confusion_matrix trong tài liệu Tìm hiểu của Scikit. Xác định hàm đó tại đây:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
Đồng thời tạo biểu đồ bằng cách truyền dữ liệu từ mô hình của chúng ta vào biểu đồ. Chúng ta đang đặt normalize thành True tại đây để ma trận nhầm lẫn hiển thị số lượng dự đoán chính xác và không chính xác dưới dạng tỷ lệ phần trăm:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Bạn sẽ thấy như sau (số liệu chính xác sẽ khác nhau):
Ở đây,chúng ta có thể thấy rằng mô hình của chúng tôi đã dự đoán khoảng 85% trong số 1.594 giao dịch gian lận từ thử nghiệm của chúng tôi được thiết lập chính xác. Lưu ý rằng trọng tâm trong phòng thí nghiệm này không phải là chất lượng mô hình – nếu đang triển khai mô hình phát hiện gian lận trong phiên bản chính thức, bạn có thể muốn độ chính xác cao hơn 85% đối với lớp gian lận. Mục tiêu của phòng thí nghiệm này là giới thiệu cho bạn công cụ giải thích các mô hình được huấn luyện trên các tập dữ liệu không cân bằng.
Tiếp theo, chúng ta sẽ sử dụng Giải thích SDK AI để tìm hiểu những tính năng mà mô hình của chúng tôi đang dựa vào để đưa ra những dự đoán này.
6. Sử dụng SDK AI có thể giải thích
SDK AI có thể giải thích cung cấp các phương thức tiện ích để nhận thông tin giải thích về mô hình của bạn. Thư viện này được cài đặt sẵn trong các phiên bản Sổ tay nền tảng AI của Tensorflow. Xin lưu ý rằng chúng tôi đã nhập Sổ tay này vào sổ tay của mình khi bắt đầu phòng thí nghiệm. Thông qua SDK, chúng ta có thể nhận thông tin phân bổ tính năng từ mô hình của mình trong phiên bản sổ tay, tức là chúng ta không cần triển khai mô hình lên đám mây để sử dụng mô hình đó.
Trong phần này, chúng ta sẽ xuất mô hình vừa huấn luyện dưới dạng Tensorflow SavedModel, sau đó trỏ SDK đến các thành phần mô hình đã lưu để nhận nội dung giải thích.
Bước 1: Xuất mô hình đã huấn luyện
Trước tiên, hãy lưu mô hình của chúng ta vào một thư mục trong thực thể sổ tay:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Nếu làm mới chế độ xem thư mục trong thanh bên bên trái của sổ tay, bạn sẽ thấy một thư mục mới có tên là fraud_model/ được tạo.
Bước 2: Lấy siêu dữ liệu nội dung giải thích qua SDK
Tiếp theo, chúng ta sẽ trỏ SDK Giải thích AI vào thư mục đó. Thao tác này sẽ tạo ra siêu dữ liệu cần thiết để giải thích mô hình. Phương thức get_metadata() hiển thị siêu dữ liệu mà SDK suy luận từ mô hình của bạn, chẳng hạn như tên đầu vào:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Khả năng giải thích giúp chúng tôi trả lời câu hỏi: "Tại sao mô hình của chúng tôi cho rằng đây là hành vi gian lận?"
Bước 3: Chỉ định đường cơ sở cho mô hình
Đối với dữ liệu dạng bảng, dịch vụ Giải thích AI hoạt động bằng cách trả về các giá trị phân bổ cho từng tính năng. Các giá trị này cho biết mức độ ảnh hưởng của một tính năng cụ thể đến thông tin dự đoán. Giả sử số tiền của một giao dịch cụ thể khiến mô hình của chúng tôi tăng xác suất gian lận dự đoán lên 0,2%. Bạn có thể đang nghĩ "0,2% liên quan đến cái gì??". Từ đó chúng ta sẽ hình thành khái niệm đường cơ sở.
Đường cơ sở của mô hình của chúng tôi về cơ bản là cơ sở để so sánh với mô hình đó. Chúng tôi chọn giá trị cơ sở cho mỗi đối tượng trong mô hình của mình và do đó, dự đoán cơ sở sẽ trở thành giá trị mà mô hình của chúng tôi dự đoán khi các đối tượng này được đặt ở đường cơ sở.
Việc chọn đường cơ sở phụ thuộc vào nhiệm vụ dự đoán mà bạn đang giải quyết. Đối với các đối tượng dạng số, thông thường bạn nên sử dụng giá trị trung bình của từng đối tượng trong tập dữ liệu làm giá trị cơ sở. Tuy nhiên, trong trường hợp phát hiện gian lận, đây không phải là điều chúng tôi mong muốn. Chúng tôi quan tâm nhất đến việc giải thích các trường hợp mà mô hình của chúng tôi gắn nhãn giao dịch là gian lận. Điều đó có nghĩa là trường hợp cơ sở mà chúng tôi muốn so sánh là các giao dịch không gian lận.
Để tính đến điều này, chúng tôi sẽ sử dụng các giá trị trung bình của các giao dịch không gian lận trong tập dữ liệu làm cơ sở. Chúng ta có thể lấy giá trị trung bình bằng cách sử dụng DataFrame not_fraud_sample đã trích xuất ở trên và điều chỉnh theo tỷ lệ cho phù hợp với dữ liệu đầu vào dự kiến của mô hình:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Xin lưu ý rằng chúng ta không cần chỉ định đường cơ sở. Nếu không, SDK sẽ sử dụng 0 làm giá trị cơ sở cho từng giá trị đầu vào mà mô hình của chúng ta đang mong đợi. Trong trường hợp sử dụng tính năng phát hiện gian lận, chúng ta nên chỉ định đường cơ sở. Dưới đây là việc chúng ta sẽ thực hiện:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
Chạy phương thức save_metadata() ở trên đã tạo một tệp trong thư mục của mô hình có tên là explanation_metadata.json. Trong sổ tay của bạn, hãy chuyển đến thư mụcphishing_model/ để xác nhận tệp đó đã được tạo. Đối tượng này chứa siêu dữ liệu mà SDK sẽ sử dụng để tạo thông tin ghi nhận sự đóng góp cho tính năng.
Bước 4: Nhận nội dung giải thích về mô hình
Hiện tại, chúng tôi đã sẵn sàng cung cấp thông tin về thuộc tính tính năng cho từng ví dụ. Để làm được việc đó, trước tiên chúng ta sẽ tạo một tham chiếu cục bộ cho mô hình của mình bằng cách sử dụng SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Tiếp theo, hãy xem các thông tin dự đoán và nội dung giải thích về mô hình của chúng tôi từ một giao dịch mẫu cần được phân loại là lừa đảo:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
Khi chạy hàm này sẽ tạo ra một hình ảnh trực quan như sau:
Trong ví dụ này, số dư ban đầu của tài khoản trước khi giao dịch diễn ra là chỉ báo gian lận lớn nhất, đẩy dự đoán của mô hình của chúng tôi lên từ đường cơ sở hơn 0,5. Số tiền của giao dịch, số dư phát sinh ở tài khoản đích và bước là những chỉ báo lớn nhất tiếp theo. Trong tập dữ liệu, cột "bước" là đơn vị thời gian (1 bước bằng 1 giờ). Giá trị phân bổ cũng có thể là số âm.
"Lỗi ước tính" được in ở phía trên hình ảnh trực quan cho biết bạn có thể tin tưởng phần giải thích đó đến mức nào. Thông thường, khi lỗi trên 5%, bạn có thể không tin tưởng được vào các thuộc tính của tính năng. Hãy nhớ rằng nội dung giải thích của bạn phụ thuộc vào dữ liệu huấn luyện và mô hình mà bạn đã sử dụng. Việc cải thiện dữ liệu huấn luyện, mô hình hoặc thử một đường cơ sở khác của mô hình có thể giúp giảm sai số ước tính.
Bạn cũng có thể giảm lỗi này bằng cách tăng số bước được sử dụng trong phương pháp giải thích. Bạn có thể thay đổi điều này thông qua SDK bằng cách thêm tham số path_count vào cấu hình giải thích (giá trị mặc định là 10 nếu bạn không chỉ định):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Bạn có thể làm được rất nhiều việc khác với công nghệ AI giải thích trong mô hình này. Sau đây là một số ý tưởng:
- Gửi nhiều ví dụ đến mô hình của chúng tôi và tính trung bình các giá trị phân bổ để xem liệu các tính năng nhất định có quan trọng hơn về tổng thể hay không. Chúng tôi có thể sử dụng thông tin này để cải thiện mô hình của mình và có thể xoá những tính năng không quan trọng
- Tìm các kết quả dương tính giả mà mô hình của chúng tôi gắn cờ là gian lận nhưng không phải là giao dịch lừa đảo, đồng thời kiểm tra các giá trị phân bổ của chúng
- Sử dụng một đường cơ sở khác và xem đường cơ sở này ảnh hưởng như thế nào đến các giá trị phân bổ
🎉 Xin chúc mừng! 🎉
Bạn đã học được cách tính đến dữ liệu không cân bằng, huấn luyện mô hình TensorFlow để phát hiện các giao dịch gian lận và dùng SDK AI có thể giải thích để xem mô hình của bạn đang dựa vào tính năng nào nhiều nhất để đưa ra từng dự đoán. Bạn có thể dừng ở đây nếu muốn. Việc sử dụng SDK trong sổ tay nhằm đơn giản hoá quá trình phát triển mô hình bằng cách cho phép bạn xem nội dung giải thích trước khi triển khai mô hình. Có thể sau khi xây dựng được mô hình mà bạn hài lòng, bạn sẽ muốn triển khai mô hình đó để nhận thông tin dự đoán trên quy mô lớn. Nếu bạn thấy như vậy, hãy tiếp tục chuyển sang bước tiếp theo (không bắt buộc). Nếu bạn đã hoàn tất, hãy chuyển đến bước Dọn dẹp.
7. Không bắt buộc: Triển khai mô hình cho tính năng Dự đoán nền tảng AI
Ở bước này, bạn sẽ tìm hiểu cách triển khai mô hình cho tính năng Dự đoán của nền tảng AI.
Bước 1: Sao chép thư mục mô hình đã lưu vào một bộ chứa trên Cloud Storage.
Với các bước SDK mà chúng tôi từng chạy, bạn đã có mọi thông tin cần thiết để triển khai mô hình của mình trên Nền tảng AI. Để chuẩn bị cho việc triển khai, bạn cần đưa các thành phần SavedModel và siêu dữ liệu của nội dung giải thích vào một Bộ chứa Cloud Storage mà dịch vụ Giải thích AI có thể đọc được.
Để làm được việc đó, chúng ta sẽ xác định một số biến môi trường. Điền tên dự án của bạn trên Google Cloud và tên của bộ chứa mà bạn muốn tạo vào các giá trị bên dưới (phải là duy nhất trên toàn hệ thống).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Bây giờ, chúng ta đã sẵn sàng tạo một bộ chứa lưu trữ để lưu trữ các thành phần mô hình TensorFlow được xuất. Chúng tôi sẽ trỏ Nền tảng AI vào bộ chứa này khi triển khai mô hình.
Chạy lệnh gsutil này từ trong sổ tay của bạn để tạo một bộ chứa:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Sau đó, hãy sao chép thư mục mô hình cục bộ vào bộ chứa đó:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Bước 2: Triển khai mô hình
Tiếp theo, chúng ta sẽ xác định một số biến sẽ sử dụng trong các lệnh triển khai:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Chúng ta có thể tạo mô hình bằng lệnh gcloud sau đây:
!gcloud ai-platform models create $MODEL --region=us-central1
Bây giờ, chúng tôi đã sẵn sàng triển khai phiên bản đầu tiên của mô hình này trên gcloud. Phiên bản này sẽ mất khoảng 5 đến 10 phút để triển khai:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
Trong cờ origin, chúng ta truyền vào vị trí Cloud Storage của mô hình và tệp siêu dữ liệu đã lưu. AI giải thích hiện có hai phương pháp giải thích khác nhau cho các mô hình bảng. Ở đây, chúng ta sẽ dùng Sampled Shapley. Tham số num-paths cho biết số lượng đường dẫn được lấy mẫu cho từng tính năng đầu vào. Nói chung, mô hình càng phức tạp, cần nhiều bước tính gần đúng hơn để đạt được sự hội tụ hợp lý.
Để xác nhận rằng mô hình của bạn đã được triển khai đúng cách, hãy chạy lệnh gcloud sau:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Trạng thái phải là READY.
Bước 3: Nhận thông tin dự đoán và nội dung giải thích về mô hình đã triển khai
Để giải thích, chúng tôi quan tâm nhất đến việc giải thích các trường hợp mà mô hình của chúng tôi dự đoán hành vi gian lận. Chúng tôi sẽ gửi 5 ví dụ thử nghiệm cho mô hình của chúng tôi nếu tất cả đều là giao dịch gian lận.
Chúng tôi sẽ sử dụng Google Cloud CLI để nhận thông tin dự đoán. Chạy mã sau để lấy chỉ mục của tất cả các ví dụ về gian lận từ tập hợp kiểm thử của chúng tôi:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Tiếp theo, chúng ta sẽ lưu 5 ví dụ ở định dạng mà mô hình đang mong đợi và ghi vào một tệp:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Chúng ta có thể gửi 5 ví dụ sau đây cho mô hình của mình bằng gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Trong tệp JSON phản hồi, bạn sẽ thấy các giá trị phân bổ cho từng tính năng trong những ví dụ này. Khoá example_score cho mỗi ví dụ bao gồm thông tin dự đoán của mô hình – trong trường hợp này là tỷ lệ phần trăm khả năng một giao dịch cụ thể là gian lận.
8. Dọn dẹp
Nếu muốn tiếp tục sử dụng sổ tay này, bạn nên tắt sổ tay khi không sử dụng. Trên giao diện người dùng của Sổ tay trong Cloud Console, hãy chọn sổ tay đó rồi chọn Dừng:
Nếu muốn xoá tất cả tài nguyên bạn đã tạo trong phòng thí nghiệm này, bạn chỉ cần xoá phiên bản của sổ tay thay vì dừng phiên bản đó.
Bằng cách sử dụng trình đơn Điều hướng trong Cloud Console, hãy duyệt đến Bộ nhớ và xoá cả hai bộ chứa bạn đã tạo để lưu trữ các thành phần mô hình.