1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ sử dụng AI Platform Notebooks để xây dựng và huấn luyện một mô hình nhằm xác định các giao dịch gian lận, đồng thời tìm hiểu các dự đoán của mô hình bằng Explainable AI SDK. Phát hiện hành vi gian lận là một loại phát hiện điểm bất thường dành riêng cho dịch vụ tài chính, đồng thời đặ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ý 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 hành vi gian lận bằng tf.keras trong AI Platform Notebooks
- Sử dụng Explainable AI SDK trong sổ tay để tìm hiểu lý do mô hình phân loại giao dịch là gian lận
- Triển khai mô hình lên Nền tảng Trí tuệ nhân tạo kèm theo nội dung giải thích, đồng thời 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 bài tập này trên Google Cloud là khoảng 1 USD.
2. Tại sao cần phát hiện hành vi gian lận?
Phát hiện hoạt động bất thường có thể là một lựa chọ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 lệ trong dữ liệu. Phát hiện hành vi gian lận là một loại phát hiện điểm bất thường và đặt ra 2 thách thức thú vị khi nói đến công nghệ học máy:
- Tập dữ liệu rất mất cân bằng: vì điểm bất thường là điểm bất thường nên không có nhiều điểm bất thường. Học máy hoạt động hiệu quả nhất khi các tập dữ liệu cân bằng, vì vậy, mọi thứ có thể trở nên phức tạp khi các giá trị ngoại lệ chiếm dưới 1% dữ liệu của bạn.
- Cần giải thích kết quả: nếu đang tìm kiếm hoạt động gian lận, có thể bạn sẽ muốn biết lý do hệ thống gắn cờ một hoạt động nào đó là gian lận thay vì chỉ tin vào lời của hệ thống. Các công cụ giải thích có thể giúp bạn thực hiện việc này.
3. Thiết lập môi trường
Bạn cần có một dự án trê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 Cloud AI Platform Models API
Chuyển đến phần Mô hình Nền tảng Trí tuệ nhân tạo của bảng điều khiển Cloud rồi nhấp vào Enable (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 Bật nếu bạn chưa bật. Bạn sẽ cần thông tin này để tạo phiên bản sổ tay.
Bước 3: Tạo một phiên bản AI Platform Notebooks
Chuyển đến mục AI Platform Notebooks của bảng điều khiển Cloud rồi nhấp vào New Instance (Phiên bản mới). Sau đó, hãy chọn loại phiên bản TensorFlow Enterprise 2.1 không có GPU:
Sử dụng các lựa 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 (Mở JupyterLab):
Khi bạn mở phiên bản này, 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 và 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 và xử lý dữ liệu
Chúng ta sẽ sử dụng tập dữ liệu được tạo theo cách giả tạo này từ Kaggle để huấn luyện mô hình. Tập dữ liệu ban đầu có 6,3 triệu hàng, trong đó có 8.000 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 Pandas
Chúng tôi đã cung cấp cho bạn tập dữ liệu Kaggle trong Google Cloud Storage. Bạn có thể tải tệp này xuống bằng cách chạy lệnh gsutil sau đây trong sổ tay Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Tiếp theo, hãy đọc tập dữ liệu 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 nội dung tương tự như sau trong bản xem trước:
Bước 2: Tính đến 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 hiện có, thì có thể mô hình sẽ đạt độ chính xác 99,9% bằng cách đoán rằng mọi giao dịch đều không phải là giao dịch gian lận chỉ vì 99,9% dữ liệu là các trường hợp không gian lận.
Có một số phương pháp để xử lý dữ liệu không cân bằng. Ở đây, chúng ta sẽ sử dụng một kỹ thuật gọi là giảm độ phân giải. Giảm mẫu có nghĩa là chỉ sử dụng một tỷ lệ nhỏ của lớp đa số trong quá trình huấn luyện. Trong trường hợp này, "không phải là gian lận" là lớp đa số vì chiếm 99,9% dữ liệu.
Để giảm kích thước mẫu cho tập dữ liệu, chúng ta sẽ lấy tất cả khoảng 8.000 ví dụ gian lận và một mẫu ngẫu nhiên gồm khoảng 31.000 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% trước đây.
Trước tiên, hãy chia dữ liệu thành 2 DataFrame, một cho giao dịch gian lận và một cho giao dịch không gian lận (chúng ta sẽ sử dụng dữ liệu này sau trong lớp học lập trình khi triển khai mô hình):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Sau đó, hãy lấy một mẫu ngẫu nhiên trong số các trường hợp không gian lận. Chúng tôi đang sử dụng 0,005% vì tỷ lệ này sẽ cho chúng ta tỷ lệ phân chia 25/75 giữa giao dịch gian lận và giao dịch không gian lận. Với dữ liệu đó, bạn có thể ghép lại và xáo trộn dữ liệu. Để đơn giản hoá, chúng ta cũng sẽ xoá một số cột mà chúng ta 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()
Giờ đây, chúng ta đã có một tập dữ liệu cân bằng hơn nhiều. Tuy nhiên, nếu nhận thấy mô hình của chúng tôi hội tụ ở độ chính xác khoảng 75%, thì có nhiều khả năng mô hình này đang đoán "không phải là gian lận" trong mọi trường hợp.
Bước 3: Chia dữ liệu thành các tập huấn luyện và tập kiểm thử
Việc cuối cùng cần làm trước khi xây dựng mô hình là phân chia dữ liệu. Chúng ta sẽ sử dụng tỷ lệ phân chia dữ liệu huấn luyện/kiểm thử là 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')
*E. A. Lopez-Rojas , A. Elmir và S. Axelsson. "PaySim: Một trình mô phỏng tiền di động tài chính để phát hiện hành vi gian lận". Trong: Hội nghị chuyên đề lần thứ 28 về mô hình hoá và mô phỏng ở Châu Âu – EMSS, Larnaca, Síp. 2016
5. Xây dựng, huấn luyện và đánh giá một mô hình tf.keras
Chúng ta sẽ xây dựng bằng API tf.keras của TensorFlow. Mã mô hình trong phần này được xây dựng dựa trên hướng dẫn này trong 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 tham số class_weight để giải quyết tình trạng 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 dạng số, bạn cần chuẩn hoá dữ liệu, đặc biệt là nếu 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 tổn thất do việc giảm độ dốc quá mức trong quá trình huấn luyện. Chúng ta có thể chuẩn hoá dữ liệu bằng cách:
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á:
train_set
Bước 2: Xác định trọng số của lớp học
Khi giảm mẫu dữ liệu, chúng tôi vẫn muốn giữ lại một nhóm nhỏ các giao dịch không gian lận để không mất thông tin về những 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 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 tăng trọng số cho các ví dụ gian lận trong tập dữ liệu.
Tham số class_weight của Keras cho phép chúng ta chỉ định chính xác mức độ quan trọng mà chúng ta muốn gán cho các ví dụ từ mỗi lớp, dựa trên tần suất xuất hiện của các ví dụ đó 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: Huấn luyện và đánh giá mô hình
Chúng ta sẽ xây dựng mô hình bằng cách sử dụng Keras Sequential Model API. API này cho phép chúng ta xác định mô hình dưới dạng một ngăn xếp các lớp. Có một số chỉ số mà chúng ta sẽ theo dõi trong quá trình huấn luyện. Các chỉ số này sẽ giúp chúng ta hiểu được hiệu suất của mô hình trên 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 số biến chung để sử dụng trong quá trình huấn luyện cùng với một số tham 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 mà chúng ta đã 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ột mô hình được huấn luyện, hãy xem hiệu suất của mô hình bằng cách vẽ biểu đồ các chỉ số trong suốt các giai đoạn 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):
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, kết quả sẽ cho chúng ta biết tỷ lệ phần trăm số ví dụ kiểm thử mà mô hình dự đoán đúng và sai. Scikit Learn có một số tiện ích để tạo và vẽ ma trận nhầm lẫn mà chúng ta sẽ sử dụng ở đây.
Khi bắt đầu sổ tay, chúng ta đã nhập tiện ích confusion_matrix. Để sử dụng, trước tiên, chúng ta sẽ tạo một danh sách các dự đoán của mô hình. Ở đây, chúng ta sẽ làm tròn các giá trị mà mô hình trả về để danh sách này khớp với danh sách nhãn thực tế:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Giờ đây, 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 nhãn chân thực:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Điều này cho chúng ta biết 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 trên tập kiểm định. Số ở trên cùng bên trái cho biết có bao nhiêu ví dụ trong tập kiểm định mà mô hình của chúng tôi dự đoán chính xác là không gian lận. Số ở dưới cùng bên phải cho biết số lượng giao dịch mà mô hình dự đoán chính xác là gian lận (chúng tôi quan tâm nhất đến con số này). Bạn có thể thấy rằng mô hình đã dự đoán chính xác phần lớn các mẫu cho từng lớp.
Để giúp bạn dễ hình dung hơn, chúng tôi đã điều chỉnh hàm plot_confusion_matrix trong tài liệu của Scikit Learn. 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')
Và tạo biểu đồ bằng cách truyền dữ liệu từ mô hình của chúng ta vào. Chúng ta sẽ đặt normalize thành True ở đâ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 nội dung tương tự như sau (các con số 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 ta đã dự đoán chính xác khoảng 85% trong số 1.594 giao dịch gian lận trong tập kiểm định. Xin 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 triển khai một mô hình phát hiện hành vi gian lận trong quá trình sản xuất, 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 về các công cụ giải thích 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 AI giải thích SDK để tìm hiểu những tính năng mà mô hình của chúng ta đang dựa vào để đưa ra những dự đoán này.
6. Sử dụng SDK AI giải thích
Explainable AI SDK 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 của Nền tảng Trí tuệ nhân tạo Tensorflow – lưu ý rằng chúng ta đã nhập thư viện này vào sổ tay ở phần đầu của lớp học lập trình. Với SDK, chúng ta có thể nhận được các thuộc tính của tính năng từ mô hình trong phiên bản sổ tay. Điều này có nghĩa là chúng ta không cần triển khai mô hình lên đám mây để sử dụng.
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 đó chỉ định SDK cho các thành phần mô hình đã lưu để nhận 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 vào một thư mục trong phiên bản 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 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 giải thích bằng SDK
Tiếp theo, chúng ta sẽ trỏ Explainable AI SDK vào thư mục đó. Thao tác này sẽ tạo siêu dữ liệu cần thiết để nhận giải thích về mô hình. Phương thức get_metadata() cho thấy 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ở của mô hình
Đối với dữ liệu dạng bảng, dịch vụ AI giải thích hoạt động bằng cách trả về các giá trị phân bổ cho từng đối tượ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 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 dự đoán gian lận thêm 0,2%. Có thể bạn đang nghĩ "0,2% so với cái gì??". Điều này đưa chúng ta đến khái niệm về đường cơ sở.
Đường cơ sở cho mô hình của chúng tôi về cơ bản là những gì mô hình đang so sánh. Chúng tôi chọn giá trị cơ sở cho từng đặc điểm 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 đặc điểm được đặt ở mức 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 đặc điểm bằng số, bạn thường dùng giá trị trung vị của từng đặc điểm trong tập dữ liệu làm đường cơ sở. Tuy nhiên, trong trường hợp phát hiện hành vi gian lận, đây không phải là điều chúng ta 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 một giao dịch là gian lận. Điều đó có nghĩa là trường hợp đường cơ sở mà chúng ta muốn so sánh là các giao dịch không gian lận.
Để giải thích cho đ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 của mình làm đường cơ sở. Chúng ta có thể lấy giá trị trung vị bằng cách sử dụng DataFrame not_fraud_sample mà chúng ta đã trích xuất ở trên và điều chỉnh tỷ lệ để khớp với các đầ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 một đường cơ sở. Nếu không, SDK sẽ dùng 0 làm đường cơ sở cho mỗi 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 phát hiện hành vi gian lận, bạn nên chỉ định một đường cơ sở. Chúng ta sẽ thực hiện việc này ở bên dưới:
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)
Việc 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, hãy chuyển đến thư mục fraud_model/ để xác nhận rằng tệp đã được tạo. Thư mục này chứa siêu dữ liệu mà SDK sẽ dùng để tạo các thuộc tính của tính năng.
Bước 4: Nhận nội dung giải thích về mô hình
Giờ đây, chúng ta đã sẵn sàng nhận các thuộc tính của đối tượng trên từng ví dụ. Để làm việc đó, trước tiên, chúng ta sẽ tạo một tham chiếu cục bộ đến mô hình bằng SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Tiếp theo, hãy lấy thông tin dự đoán và giải thích về mô hình của chúng ta từ một giao dịch mẫu cần được phân loại là gian lận:
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, thao tác này sẽ tạo ra một hình ảnh trực quan có dạng 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 lớn nhất về hành vi gian lận, đẩy dự đoán của mô hình lên hơn 0,5 so với đường cơ sở. Số tiền giao dịch, số dư cuối cùng trong tài khoản đích và bước là những chỉ báo lớn tiếp theo. Trong tập dữ liệu, "step" (bước) biểu thị một đơn vị thời gian (1 bước là 1 giờ). Giá trị phân bổ cũng có thể là số âm.
"Lỗi xấp xỉ" được in ở phía trên các hình ảnh trực quan cho biết mức độ tin cậy của lời giải thích. Nhìn chung, nếu tỷ lệ lỗi trên 5% thì có nghĩa là bạn không thể dựa vào các thuộc tính của tính năng. Hãy nhớ rằng lời giải thích của bạn chỉ có độ chính xác tương đương với 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ở mô hình khác có thể giảm sai số xấp xỉ.
Bạn cũng có thể giảm lỗi này bằng cách tăng số bước được dùng trong phương thức giải thích. Bạn có thể thay đổi thông số này bằng SDK bằng cách thêm một tham số path_count vào cấu hình giải thích (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 nhiều việc hơn nữa nhờ AI có thể giải thích trên mô hình này. Một số ý tưởng bao gồm:
- Gửi nhiều ví dụ cho mô hình của chúng tôi và tính giá trị phân bổ trung bình để xem liệu một số tính năng 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ể loại bỏ những tính năng không quan trọng
- Tìm những 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 lại là giao dịch không gian lận, đồng thời kiểm tra các giá trị phân bổ của những kết quả đó
- Sử dụng một đường cơ sở khác và xem mức độ ảnh hưởng của đường cơ sở này đến các giá trị phân bổ
🎉 Xin chúc mừng! 🎉
Bạn đã tìm hiểu cách lưu giữ hồ sơ dữ liệu không cân bằng, huấn luyện một mô hình TensorFlow để phát hiện giao dịch gian lận và sử dụng Explainable AI SDK để xem mô hình AI giải thích của bạn đang dựa vào những tính năng nào nhất để đưa ra từng dự đoán. Bạn có thể dừng tại đây nếu muốn. Việc sử dụng SDK trong sổ tay nhằm mục đích đơn giản hoá quy trình phát triển mô hình bằng cách cho phép bạn truy cập vào các giải thích trước khi triển khai mô hình. Rất có thể sau khi xây dựng một mô hình mà bạn hài lòng, bạn sẽ muốn triển khai mô hình đó để nhận được các dự đoán ở quy mô lớn. Nếu bạn thuộc trường hợp này, hãy 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 sang bước Dọn dẹp.
7. Không bắt buộc: Triển khai mô hình cho Nền tảng Trí tuệ nhân tạo Dự đoán
Trong bước này, bạn sẽ tìm hiểu cách triển khai mô hình của mình cho AI Platform Prediction.
Bước 1: Sao chép thư mục mô hình đã lưu vào một bộ chứa Cloud Storage.
Với các bước SDK mà chúng ta đã chạy trước đó, bạn có mọi thứ cần thiết để triển khai mô hình của mình lên Nền tảng Trí tuệ nhân tạo. Để chuẩn bị triển khai, bạn cần đặt các thành phần SavedModel và siêu dữ liệu giải thích vào một bộ chứa Cloud Storage mà dịch vụ AI có thể giải thích có thể đọc.
Để làm việc đó, chúng ta sẽ xác định một số biến môi trường. Điền các giá trị bên dưới bằng tên dự án trên đám mây Google Cloud và tên bộ chứa mà bạn muốn tạo (phải là tên duy nhất trên toàn cầu).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Giờ đây, chúng ta đã sẵn sàng tạo một vùng lưu trữ để lưu trữ các tài sản mô hình TensorFlow đã xuất. Chúng ta sẽ chỉ định Nền tảng Trí tuệ nhân tạo vào nhóm này khi triển khai mô hình.
Chạy lệnh gsutil này trong sổ tay để tạo một nhóm:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Sau đó, hãy sao chép thư mục mô hình cục bộ vào nhóm đó:
!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 mà chúng ta 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:
!gcloud ai-platform models create $MODEL --region=us-central1
Giờ đây, chúng ta đã sẵn sàng triển khai phiên bản đầu tiên của mô hình này bằng 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ị trí Cloud Storage của mô hình đã lưu và tệp siêu dữ liệu. AI có thể giải thích hiện có 2 phương pháp giải thích khác nhau cho các mô hình dạng bảng. Ở đây, chúng ta đang sử dụng Shapley lấy mẫu. Tham số num-paths cho biết số lượng đường dẫn được lấy mẫu cho mỗi đối tượng đầu vào. Nhìn chung, mô hình càng phức tạp thì càng cần nhiều bước xấp xỉ để đạt được mức độ 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à 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 những trường hợp mà mô hình của chúng tôi dự đoán là gian lận. Chúng tôi sẽ gửi 5 ví dụ kiểm thử đến mô hình của mình, tất cả đều là giao dịch gian lận.
Chúng ta 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ề hành vi gian lận trong tập kiểm định 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 của chúng ta mong đợi và ghi chúng 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ụ này đến mô hình bằng cách sử dụng gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Trong JSON phản hồi, bạn sẽ thấy các giá trị phân bổ cho từng đối tượng trong các ví dụ này. Khoá example_score cho mỗi ví dụ bao gồm 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 dùng. Trong giao diện người dùng Notebooks của Cloud Console, hãy chọn sổ tay rồi chọn Dừng:
Nếu bạn muốn xoá tất cả tài nguyên đã tạo trong phòng thí nghiệm này, chỉ cần xoá phiên bản sổ tay thay vì dừng phiên bản đó.
Sử dụng trình đơn Điều hướng trong Cloud Console, duyệt tìm Storage rồi xoá cả hai vùng chứa mà bạn đã tạo để lưu trữ các thành phần mô hình.