1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้ใช้สมุดบันทึก AI เพื่อสร้างและฝึกโมเดลสำหรับการระบุธุรกรรมที่เป็นการฉ้อโกง รวมถึงทำความเข้าใจการคาดการณ์ของโมเดลด้วย Explainable AI SDK การตรวจจับการประพฤติมิชอบเป็นการตรวจจับความผิดปกติประเภทหนึ่งสำหรับบริการทางการเงินโดยเฉพาะ และนำเสนอความท้าทายที่น่าสนใจสำหรับโมเดล ML ซึ่งได้แก่ ชุดข้อมูลที่ไม่สมดุลโดยธรรมชาติและความต้องการในการอธิบายผลลัพธ์ของโมเดล
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- จัดการชุดข้อมูลที่ไม่สมดุล
- สร้างและประเมินโมเดลการตรวจจับการประพฤติมิชอบด้วย tf.keras ในสมุดบันทึกของ AI Platform
- ใช้ Explainable AI SDK จากภายในสมุดบันทึกเพื่อทําความเข้าใจสาเหตุที่โมเดลจัดหมวดหมู่ธุรกรรมเป็นการฉ้อโกง
- ทำให้โมเดลใช้งานได้ใน AI Platform พร้อมคำอธิบาย รวมถึงรับการคาดการณ์และคำอธิบายเกี่ยวกับโมเดลที่ทำให้ใช้งานได้แล้ว
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $1
2. เหตุใดจึงต้องตรวจจับการประพฤติมิชอบ
การตรวจจับความผิดปกติเป็นตัวเลือกที่ดีสำหรับแมชชีนเลิร์นนิงเนื่องจากมักจะเขียนชุดคำสั่งตามกฎเพื่อระบุความผิดปกติในข้อมูลได้ยาก การตรวจจับการประพฤติมิชอบเป็นการตรวจจับความผิดปกติประเภทหนึ่งและนำเสนอความท้าทายที่น่าสนใจ 2 ข้อเกี่ยวกับแมชชีนเลิร์นนิง ดังนี้
- ชุดข้อมูลที่ไม่สมดุลอย่างมาก: เนื่องจากความผิดปกติคือความผิดปกติ จึงมีเพียงไม่กี่อย่างเท่านั้น ML จะทำงานได้ดีที่สุดเมื่อชุดข้อมูลมีความสมดุล ดังนั้นสิ่งต่างๆ อาจซับซ้อนขึ้นเมื่อค่าผิดปกติมีข้อมูลน้อยกว่า 1%
- จำเป็นต้องอธิบายผลลัพธ์: หากคุณกำลังมองหากิจกรรมที่เป็นการฉ้อโกง คุณคงอยากรู้ว่าทำไมระบบจึงแจ้งว่าบางสิ่งเป็นการฉ้อโกงแทนที่จะแค่เชื่อเฉยๆ เครื่องมือคำอธิบายช่วยในเรื่องนี้ได้
3. ตั้งค่าสภาพแวดล้อมของคุณ
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Cloud AI Platform Models API
ไปที่ส่วนโมเดล AI Platform ของ Cloud Console แล้วคลิกเปิดใช้ หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ ซึ่งคุณจะต้องใช้ในการสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 3: สร้างอินสแตนซ์ AI Platform Notebooks
ไปที่ส่วน AI Platform Notebooks ของ Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.1 ที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้นแล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab:
เมื่อเปิดอินสแตนซ์ ให้เลือกสมุดบันทึก Python 3 จาก Launcher ดังนี้
ขั้นตอนที่ 4: นำเข้าแพ็กเกจ Python
สร้างเซลล์ใหม่และนำเข้าไลบรารีที่เราจะใช้ใน Codelab นี้
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. ดาวน์โหลดและประมวลผลข้อมูล
เราจะใช้ชุดข้อมูลสังเคราะห์นี้จาก Kaggle เพื่อฝึกโมเดลของเรา ชุดข้อมูลต้นฉบับประกอบด้วยแถว 6.3 ล้านแถว ซึ่ง 8, 000 แถวเป็นธุรกรรมที่เป็นการฉ้อโกง ซึ่งคิดเป็น 0.1% ของชุดข้อมูลทั้งหมดเท่านั้น
ขั้นตอนที่ 1: ดาวน์โหลดชุดข้อมูล Kaggle และอ่านด้วย Pandas
เราได้ทำให้ชุดข้อมูล Kaggle ใช้งานได้ใน Google Cloud Storage สำหรับคุณ คุณจะดาวน์โหลดได้โดยเรียกใช้คำสั่ง gsutil ต่อไปนี้ในสมุดบันทึก Jupyter
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
ต่อไป ให้อ่านชุดข้อมูลในฐานะ Pandas DataFrame และดูตัวอย่าง
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
คุณควรเห็นสิ่งต่อไปนี้ในตัวอย่าง
ขั้นตอนที่ 2: การพิจารณาข้อมูลที่ไม่สมดุล
ดังที่กล่าวไว้ข้างต้น ขณะนี้ชุดข้อมูลมีตัวอย่างที่ไม่เป็นการฉ้อโกง 99.9% หากเราฝึกโมเดลกับข้อมูลตามที่เป็นอยู่ โมเดลจะมีความถูกต้อง 99.9% จากการคาดเดาว่าธุรกรรมทุกรายการไม่ใช่ธุรกรรมที่เป็นการฉ้อโกงเพียงเพราะข้อมูล 99.9% เป็นกรณีฉ้อโกง
วิธีจัดการกับข้อมูลที่ไม่สมดุลนั้นมีหลายวิธี ในที่นี้ เราจะใช้เทคนิคที่เรียกว่าการสุ่มตัวอย่าง การสุ่มตัวอย่างหมายถึงการใช้กลุ่มส่วนใหญ่ในการฝึกเพียงไม่กี่เปอร์เซ็นต์ ในกรณีนี้ ระบุว่า "ไม่ใช่การฉ้อโกง" เป็นกลุ่มคนส่วนใหญ่ เพราะมีข้อมูล 99.9%
ในการสุ่มตัวอย่างชุดข้อมูลของเรา เราจะนำตัวอย่างที่เป็นการฉ้อโกงทั้งหมดประมาณ 8,000 รายการและตัวอย่างแบบสุ่มซึ่งเป็นกรณีที่ไม่ใช่การฉ้อโกงประมาณ 31,000 รายการ วิธีนี้ทำให้ชุดข้อมูลผลลัพธ์มีกรณีการประพฤติมิชอบ 25% เมื่อเทียบกับ 0.1% ที่เรามีก่อนหน้านี้
ก่อนอื่น ให้แยกข้อมูลออกเป็น 2 ส่วน DataFrame ส่วนแรกสำหรับการฉ้อโกงและอีกส่วนมีไว้เพื่อไม่ฉ้อโกง (เราจะใช้ข้อมูลนี้ในภายหลังใน Codelab เมื่อเราทำให้โมเดลของเราใช้งานได้)
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
จากนั้นจึงสุ่มเก็บตัวอย่างกรณีที่ไม่ใช่การฉ้อโกง เราใช้ .005% เพราะจะทำให้เราแบ่งธุรกรรมที่ไม่ใช่การฉ้อโกง/ไม่ฉ้อโกงออกเป็น 25 / 75 เพื่อให้คุณสามารถใส่ข้อมูลกลับเข้าด้วยกันและสับเปลี่ยนได้ เราจะนำคอลัมน์ 2-3 คอลัมน์ที่เราจะไม่ใช้ในการฝึกออกเพื่อให้สิ่งต่างๆ ง่ายขึ้น
# 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()
ตอนนี้เรามีชุดข้อมูลที่สมดุลมากขึ้น อย่างไรก็ตาม หากเราพบว่าโมเดลของเรามีความแม่นยำประมาณ 75% ก็มีโอกาสสูงที่โมเดลจะเดาได้ว่า "ไม่ใช่การฉ้อโกง" ในทุกกรณี
ขั้นตอนที่ 3: แยกข้อมูลออกเป็นชุดทดสอบและชุดทดสอบ
สิ่งสุดท้ายที่ต้องทำก่อนสร้างโมเดลคือการแยกข้อมูล เราจะใช้การแบ่งการทดสอบการฝึก 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. โลเปซ-โรยาส อ. เอลเมียร์ และเอส. Axelsson "PaySim: เครื่องมือจำลองการเงินบนมือถือสำหรับตรวจจับการประพฤติมิชอบ" ใน: The 28th European Modeling and Simposium-EMSS, Larnaca, Cyprus 2016
5. สร้าง ฝึก และประเมินโมเดล tf.keras
เรากำลังสร้างโดยใช้ tf.keras API ของ TensorFlow โค้ดโมเดลในส่วนนี้สร้างขึ้นตามบทแนะนำนี้จากเอกสาร TensorFlow ก่อนอื่น เราจะทำให้ข้อมูลเป็นมาตรฐาน จากนั้นจึงสร้างและฝึกโมเดลโดยใช้พารามิเตอร์ class_weight เพื่อชดเชยความไม่สมดุลของข้อมูลที่เหลืออยู่
ขั้นตอนที่ 1: ปรับข้อมูลให้เป็นมาตรฐาน
เมื่อฝึกโมเดลเกี่ยวกับข้อมูลตัวเลข คุณควรทำให้ข้อมูลเป็นมาตรฐาน โดยเฉพาะอย่างยิ่งหากแต่ละคอลัมน์อยู่ในช่วงที่ต่างกัน ซึ่งจะช่วยป้องกันไม่ให้ข้อมูลรั่วไหลในระหว่างการฝึก เราสามารถทำให้ข้อมูลของเราเป็นมาตรฐานได้ด้วยข้อมูลต่อไปนี้
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)
ถัดไป เรามาดูตัวอย่างข้อมูลมาตรฐานกัน
train_set
ขั้นตอนที่ 2: ระบุน้ำหนักคลาส
เมื่อเราสุ่มตัวอย่างข้อมูล เรายังคงต้องการเก็บรักษาบางส่วนของธุรกรรมที่ไม่ใช่การฉ้อโกง เพื่อไม่ให้ข้อมูลเกี่ยวกับธุรกรรมเหล่านั้นสูญหาย ดังนั้นเราจึงไม่ได้ทำให้ข้อมูลมีความสมดุลอย่างสมบูรณ์ เนื่องจากชุดข้อมูลยังมีความไม่สมดุลและเราให้ความสำคัญกับการระบุธุรกรรมที่เป็นการฉ้อโกงอย่างถูกต้อง จึงต้องการให้โมเดลให้น้ำหนักมากขึ้นแก่ตัวอย่างที่เป็นการฉ้อโกงในชุดข้อมูล
พารามิเตอร์ class_weight ของ Keras ช่วยให้เราระบุน้ำหนักที่เราต้องการยกตัวอย่างจากคลาสแต่ละรายการได้ โดยอิงตามความถี่ที่พารามิเตอร์เหล่านี้เกิดขึ้นในชุดข้อมูล ดังนี้
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}
เราจะใช้ตัวแปรนี้เมื่อฝึกโมเดลในขั้นตอนถัดไป
ขั้นตอนที่ 3: ฝึกและประเมินโมเดล
เราจะสร้างโมเดลของเราโดยใช้ Keras Serial Model API ซึ่งช่วยให้เรากำหนดโมเดลของเราเป็นชุดเลเยอร์ได้ มีเมตริกจำนวนมากที่เราจะติดตามขณะฝึก ซึ่งจะช่วยให้เข้าใจประสิทธิภาพของโมเดลในแต่ละคลาสในชุดข้อมูล
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
จากนั้นเราจะกำหนดตัวแปรร่วม 2-3 รายการสำหรับใช้ในระหว่างการฝึกพร้อมกับพารามิเตอร์การหยุดก่อนกำหนด
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
สุดท้าย เราจะเรียกฟังก์ชันที่เรากำหนดไว้ข้างต้นเพื่อทำให้โมเดลของเรา:
model = make_model()
model.summary()
เราสามารถฝึกโมเดลของเราด้วยเมธอด fit() โดยส่งในพารามิเตอร์ที่กำหนดข้างต้น
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)
การฝึกจะใช้เวลาไม่กี่นาที
ขั้นตอนที่ 4: แสดงภาพเมตริกโมเดล
ตอนนี้เรามีโมเดลที่ฝึกแล้ว มาดูประสิทธิภาพของโมเดลด้วยการพล็อตเมตริกต่างๆ ตลอดช่วงเวลาการฝึก ดังนี้
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)
กราฟของคุณควรมีลักษณะคล้ายคลึงกับข้อความต่อไปนี้ (แต่จะไม่เหมือนกันทั้งหมด)
ขั้นตอนที่ 5: พิมพ์เมทริกซ์ความสับสน
เมทริกซ์ความสับสนเป็นวิธีที่ดีในการแสดงภาพประสิทธิภาพของโมเดลในชุดข้อมูลทดสอบ สำหรับแต่ละคลาส ระบบจะแสดงเปอร์เซ็นต์ของตัวอย่างการทดสอบที่โมเดลของเราคาดการณ์ได้ถูกต้องและไม่ถูกต้อง Scikit Learn มียูทิลิตีสำหรับการสร้างและพล็อตเมทริกซ์ความสับสน ซึ่งเราจะใช้ที่นี่
ในตอนต้นของสมุดบันทึก เราได้นำเข้ายูทิลิตี confusion_matrix ในการใช้งาน เราจะสร้างรายการการคาดการณ์ของโมเดลก่อน ในที่นี้ เราจะปัดเศษค่าที่แสดงผลจากโมเดลของเรา เพื่อให้รายการนี้ตรงกับรายการป้ายกำกับข้อมูลจากการสังเกตการณ์โดยตรง
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
ตอนนี้เราพร้อมที่จะป้อนข้อมูลนี้ในเมธอด confusion_matrix พร้อมกับป้ายกำกับข้อมูลจากการสังเกตการณ์โดยตรง:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
ค่านี้แสดงจำนวนสัมบูรณ์ของการคาดการณ์ที่ถูกต้องและไม่ถูกต้องของโมเดลในชุดทดสอบของเรา ตัวเลขที่ด้านบนซ้ายแสดงจำนวนตัวอย่างจากชุดการทดสอบของเรา ซึ่งมีการคาดการณ์อย่างถูกต้องว่าไม่เป็นการฉ้อโกง ตัวเลขที่ด้านขวาล่างแสดงจำนวนที่คาดการณ์ว่าเป็นการฉ้อโกง (เราให้ความสำคัญกับตัวเลขนี้มากที่สุด) คุณจะเห็นว่าเครื่องมือนี้คาดการณ์ตัวอย่างส่วนใหญ่ได้อย่างถูกต้องสำหรับแต่ละคลาส
เราได้ปรับฟังก์ชัน plot_confusion_matrix จากเอกสาร Scikit Learn เพื่อช่วยให้เห็นภาพได้ง่ายขึ้น กำหนดฟังก์ชันดังกล่าวที่นี่
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')
แล้วสร้างพล็อตโดยส่งข้อมูลจากโมเดลของเรา เรากำลังตั้งค่า normalize เป็น True เพื่อให้เมทริกซ์ความสับสนจะแสดงจำนวนการคาดการณ์ที่ถูกต้องและไม่ถูกต้องเป็นเปอร์เซ็นต์ ดังนี้
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
คุณควรจะเห็นข้อมูลดังนี้ (ตัวเลขที่แน่นอนจะแตกต่างกันไป)
จากตรงนี้ เราจะเห็นว่าโมเดลของเราคาดการณ์ธุรกรรมที่ทุจริตประมาณ 85% ของ 1,594 รายการจากชุดทดสอบของเราอย่างถูกต้อง โปรดทราบว่าห้องทดลองนี้ไม่ได้มุ่งเน้นไปที่คุณภาพของโมเดล หากคุณนำโมเดลการตรวจจับการฉ้อโกงในเวอร์ชันที่ใช้งานจริงมาใช้ ก็น่าจะต้องการระดับความแม่นยำในการจัดประเภทที่สูงกว่า 85% เป้าหมายของห้องทดลองนี้คือการแนะนำเครื่องมือในการอธิบายเกี่ยวกับโมเดลที่ได้รับการฝึกบนชุดข้อมูลที่ไม่สมดุล
ต่อไป เราจะใช้ Explainable AI SDK เพื่อทำความเข้าใจว่าโมเดลของเราใช้ฟีเจอร์ใดในการคาดการณ์เหล่านี้
6. การใช้ Explainable AI SDK
Explainable AI SDK มีวิธีที่เป็นประโยชน์ในการดูคำอธิบายเกี่ยวกับโมเดลของคุณ ซึ่งจะติดตั้งมาล่วงหน้าในอินสแตนซ์ Tensorflow AI Platform Notebook โปรดทราบว่าเรานำเข้ามาในสมุดบันทึกเมื่อเริ่มต้นห้องทดลอง เมื่อใช้ SDK เราจะรับการระบุแหล่งที่มาฟีเจอร์จากโมเดลของเราภายในอินสแตนซ์สมุดบันทึก ซึ่งหมายความว่าเราไม่จําเป็นต้องทำให้โมเดลของเราใช้งานได้บนระบบคลาวด์
ในส่วนนี้ เราจะส่งออกโมเดลที่เราเพิ่งฝึกเป็น Tensorflow savedModel แล้วชี้ SDK ไปยังเนื้อหาโมเดลที่บันทึกไว้เพื่อดูคำอธิบาย
ขั้นตอนที่ 1: ส่งออกโมเดลที่ฝึกแล้ว
ก่อนอื่น ให้บันทึกโมเดลของเราลงในไดเรกทอรีในอินสแตนซ์สมุดบันทึกของเรา:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
หากคุณรีเฟรชมุมมองโฟลเดอร์ในแถบด้านข้างทางซ้ายของสมุดบันทึก คุณจะเห็นไดเรกทอรีใหม่ชื่อ fraud_model/ ที่สร้างขึ้น
ขั้นตอนที่ 2: รับข้อมูลเมตาคำอธิบายด้วย SDK
ถัดไป เราจะชี้ Explainable AI SDK ไปยังไดเรกทอรีดังกล่าว การทำเช่นนี้จะสร้างข้อมูลเมตาที่จำเป็นสำหรับการรับคำอธิบายโมเดล เมธอด get_metadata() จะแสดงข้อมูลเมตาที่ SDK อนุมานจากโมเดลของคุณ เช่น ชื่ออินพุต
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
คำอธิบายได้ช่วยให้เราตอบคำถามที่ว่า "ทำไมโมเดลของเราถึงคิดว่านี่เป็นการฉ้อโกง"
ขั้นตอนที่ 3: การระบุเกณฑ์พื้นฐานของโมเดล
สำหรับข้อมูลแบบตาราง บริการ Explainable AI ทำงานโดยแสดงผลค่าการระบุแหล่งที่มาของแต่ละฟีเจอร์ ค่าเหล่านี้เป็นตัวบ่งชี้ว่าฟีเจอร์หนึ่งๆ มีผลต่อการคาดการณ์มากน้อยเพียงใด สมมติว่าจำนวนของธุรกรรมหนึ่งๆ ทำให้โมเดลของเรามีโอกาสในการฉ้อโกงที่คาดการณ์ไว้เพิ่มขึ้น 0.2% คุณอาจคิดว่า "0.2% เมื่อเทียบกับอะไร" สิ่งเหล่านี้นำมาสู่แนวคิดของเกณฑ์พื้นฐาน
เกณฑ์พื้นฐานสำหรับโมเดลของเราก็คือสิ่งที่นำมาเปรียบเทียบกัน เราเลือกค่าเกณฑ์พื้นฐานสำหรับแต่ละฟีเจอร์ในโมเดลของเรา ผลที่ได้คือการคาดการณ์พื้นฐานจะกลายเป็นค่าที่โมเดลของเราคาดการณ์เมื่อมีการกำหนดฟีเจอร์ไว้ที่ค่าพื้นฐาน
การเลือกเกณฑ์พื้นฐานขึ้นอยู่กับงานการคาดการณ์ที่คุณกำลังแก้โจทย์ สำหรับฟีเจอร์ที่เป็นตัวเลข เป็นเรื่องปกติที่จะใช้ค่ามัธยฐานของแต่ละฟีเจอร์ในชุดข้อมูลเป็นเกณฑ์พื้นฐาน อย่างไรก็ตาม ในกรณีของการตรวจจับการฉ้อโกง นี่ไม่ใช่สิ่งที่เราต้องการ เราให้ความสำคัญกับการอธิบายกรณีที่โมเดลของเราติดป้ายกำกับธุรกรรมว่าเป็นการฉ้อโกง ซึ่งหมายความว่ากรณีพื้นฐานที่เราต้องการเปรียบเทียบคือธุรกรรมที่ไม่ใช่การฉ้อโกง
สําหรับกรณีนี้ เราจะใช้ค่ามัธยฐานของธุรกรรมที่ไม่ใช่การฉ้อโกงในชุดข้อมูลเป็นเกณฑ์พื้นฐาน เราจะหาค่ามัธยฐานได้โดยใช้ not_fraud_sample DataFrame ที่ดึงมาข้างต้น แล้วปรับขนาดให้ตรงกับอินพุตที่คาดไว้ของโมเดลของเรา
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)
โปรดทราบว่าเราไม่ต้องระบุเกณฑ์พื้นฐาน หากไม่เป็นเช่นนั้น SDK จะใช้ 0 เป็นเกณฑ์พื้นฐานสำหรับค่าอินพุตแต่ละค่าที่เราคาดการณ์ไว้ ใน Use Case การตรวจจับการฉ้อโกง การระบุพื้นฐานซึ่งเราจะทำด้านล่างนี้
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)
การเรียกใช้เมธอด save_metadata() ด้านบนได้สร้างไฟล์ในไดเรกทอรีของโมเดลชื่อว่า explanation_metadata.json แล้ว ในสมุดบันทึก ให้ไปที่ไดเรกทอรี rock_model/ เพื่อยืนยันว่าสร้างไฟล์แล้ว ส่วนนี้มีข้อมูลเมตาที่ SDK จะใช้ในการสร้างการระบุแหล่งที่มาของฟีเจอร์
ขั้นตอนที่ 4: การรับคำอธิบายโมเดล
ตอนนี้เราพร้อมที่จะรับการระบุแหล่งที่มาฟีเจอร์ในตัวอย่างแต่ละรายการแล้ว ก่อนอื่น เราจะสร้างการอ้างอิงในตัวเครื่องไปยังโมเดลของเราโดยใช้ SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
ต่อไป ลองรับการคาดการณ์และคำอธิบายเกี่ยวกับโมเดลของเราจากตัวอย่างธุรกรรมที่ควรจัดประเภทเป็นการฉ้อโกง ดังนี้
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()
การเรียกใช้โค้ดควรสร้างการแสดงภาพที่มีลักษณะดังนี้
ในตัวอย่างนี้ ยอดดุลเริ่มต้นของบัญชีก่อนการทำธุรกรรมคือ ตัวบ่งชี้ที่ดีที่สุดของการฉ้อโกง ซึ่งทำให้การคาดการณ์ของโมเดลของเราเพิ่มขึ้นจากเกณฑ์พื้นฐานที่มากกว่า 0.5 จำนวนเงินของธุรกรรม ซึ่งเป็นผลมาจากยอดคงเหลือของบัญชีปลายทาง และขั้นตอนคือตัวบ่งชี้ที่สำคัญที่สุดถัดไป ในชุดข้อมูล "ขั้นตอน" หมายถึงหน่วยเวลา (1 ขั้นตอนคือ 1 ชั่วโมง) ค่าการระบุแหล่งที่มาอาจเป็นค่าลบได้เช่นกัน
"ข้อผิดพลาดในการประมาณ" ที่พิมพ์อยู่ด้านบนการแสดงภาพจะช่วยให้คุณทราบว่าคุณสามารถเชื่อถือคำอธิบายได้มากน้อยเพียงใด โดยทั่วไปแล้ว ข้อผิดพลาดมากกว่า 5% หมายความว่าคุณอาจไม่สามารถใช้การระบุแหล่งที่มาของฟีเจอร์ได้ โปรดทราบว่าคำอธิบายจะดีแค่ไหนนั้นขึ้นอยู่กับข้อมูลการฝึกและโมเดลที่คุณใช้ การปรับปรุงข้อมูลการฝึก โมเดล หรือการทดลองใช้เกณฑ์พื้นฐานของโมเดลอื่นอาจลดข้อผิดพลาดในการประมาณได้
นอกจากนี้ คุณยังลดข้อผิดพลาดนี้ได้โดยเพิ่มจำนวนขั้นตอนที่ใช้ในวิธีการอธิบาย คุณเปลี่ยนค่านี้ได้ด้วย SDK โดยเพิ่มพารามิเตอร์ path_count ลงในการกำหนดค่าคำอธิบาย (ค่าเริ่มต้นคือ 10 หากไม่ระบุ) ดังนี้
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
คุณใช้ AI ที่อธิบายได้บนโมเดลนี้ได้อีกหลายอย่าง ลองดูไอเดียต่อไปนี้เป็นตัวอย่าง
- ส่งตัวอย่างจำนวนมากไปยังโมเดลของเรา และหาค่าเฉลี่ยของมูลค่าการระบุแหล่งที่มา เพื่อดูว่าคุณลักษณะบางอย่างมีความสำคัญมากกว่าในภาพรวมหรือไม่ เราสามารถใช้ข้อมูลนี้เพื่อปรับปรุงโมเดลและอาจนำฟีเจอร์ที่ไม่สำคัญออก
- พบข้อสันนิษฐานที่เป็นเท็จว่าโมเดลของเราแจ้งว่าเป็นการฉ้อโกง แต่เป็นธุรกรรมที่ไม่ใช่การฉ้อโกง และได้ตรวจสอบมูลค่าการระบุแหล่งที่มาของธุรกรรมเหล่านั้น
- ใช้เกณฑ์พื้นฐานอื่น และดูว่าจะส่งผลต่อมูลค่าการระบุแหล่งที่มาอย่างไร
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีจัดการกับข้อมูลที่ไม่สมดุล ฝึกโมเดล TensorFlow ให้ตรวจจับธุรกรรมที่เป็นการฉ้อโกง และใช้ Explainable AI SDK เพื่อดูว่าฟีเจอร์ใดที่โมเดลของคุณพึ่งพามากที่สุดในการคาดการณ์แต่ละรายการแล้ว คุณสามารถหยุดที่นี่หากต้องการ การใช้ SDK ภายในสมุดบันทึกมีขึ้นเพื่อลดความซับซ้อนของกระบวนการพัฒนาโมเดลโดยให้สิทธิ์เข้าถึงคำอธิบายก่อนที่คุณจะทำให้โมเดลใช้งานได้ เมื่อคุณสร้างโมเดลที่สนใจแล้ว คุณอาจต้องการนำโมเดลไปใช้เพื่อรับการคาดการณ์ในวงกว้าง หากเป็นเช่นนั้น ให้ไปยังขั้นตอนถัดไป (ไม่บังคับ) เมื่อเสร็จแล้ว ให้ข้ามไปที่ขั้นตอนล้างข้อมูล
7. ไม่บังคับ: ทำให้โมเดลใช้งานได้กับการคาดการณ์ AI Platform
ในขั้นตอนนี้ คุณจะได้ดูวิธีทำให้โมเดลใช้งานได้กับ AI Platform Prediction
ขั้นตอนที่ 1: คัดลอกไดเรกทอรีโมเดลที่บันทึกไว้ไปยังที่เก็บข้อมูล Cloud Storage
ขั้นตอน SDK ที่เราทำก่อนหน้านี้ทำให้คุณมีทุกสิ่งที่ต้องใช้ในการทำให้โมเดลใช้งานได้กับ AI Platform เพื่อเตรียมพร้อมสำหรับการทำให้ใช้งานได้ คุณจะต้องใส่เนื้อหา ระบบจะบันทึกโมเดลและข้อมูลเมตาคำอธิบายไว้ในที่เก็บข้อมูล Cloud Storage ที่บริการ Explainable AI จะอ่านได้
เราจะกำหนดตัวแปรสภาพแวดล้อมบางอย่างเพื่อดำเนินการดังกล่าว กรอกค่าด้านล่างโดยระบุชื่อโปรเจ็กต์ Google Cloud และชื่อที่เก็บข้อมูลที่ต้องการสร้าง (ต้องไม่ซ้ำกันทั่วโลก)
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
ตอนนี้เราพร้อมที่จะสร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูลเพื่อจัดเก็บเนื้อหาโมเดล TensorFlow ที่ส่งออกแล้ว เราจะชี้ AI Platform มาที่ที่เก็บข้อมูลนี้เมื่อทำให้โมเดลใช้งานได้
เรียกใช้คำสั่ง gsutil นี้จากภายในสมุดบันทึกเพื่อสร้างที่เก็บข้อมูล
!gsutil mb -l 'us-central1' $MODEL_BUCKET
จากนั้นคัดลอกไดเรกทอรีโมเดลในเครื่องไปยังที่เก็บข้อมูลดังกล่าว
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
ขั้นตอนที่ 2: ทำให้โมเดลใช้งานได้
ต่อไป เราจะกำหนดตัวแปรบางส่วนที่เราจะใช้ในคำสั่งการติดตั้งใช้งานของเรา:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
เราสร้างโมเดลด้วยคำสั่ง gcloud ต่อไปนี้ได้
!gcloud ai-platform models create $MODEL --region=us-central1
ตอนนี้เราก็พร้อมที่จะทำให้โมเดลนี้ในเวอร์ชันแรกใช้งานได้ด้วย gcloud เวอร์ชันนี้จะใช้เวลาประมาณ 5-10 นาทีในการทำให้ใช้งานได้:
!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
ในแฟล็ก origin เราจะส่งตำแหน่ง Cloud Storage ของโมเดลและไฟล์ข้อมูลเมตาที่บันทึกไว้ ปัจจุบัน AI แบบอธิบายได้มีวิธีการอธิบายที่แตกต่างกัน 2 วิธีสําหรับโมเดลแบบตาราง เราใช้ Sampled Shapley อยู่ พารามิเตอร์ num-paths ระบุจำนวนของเส้นทางที่เก็บตัวอย่างสำหรับฟีเจอร์อินพุตแต่ละรายการ โดยทั่วไป ยิ่งโมเดลมีความซับซ้อนมากเท่าไหร่ ก็ยิ่งต้องการขั้นตอนค่าประมาณมากขึ้นเท่านั้นเพื่อให้ได้การลู่เข้าที่เหมาะสม
หากต้องการยืนยันว่าโมเดลใช้งานได้อย่างถูกต้อง ให้เรียกใช้คำสั่ง gcloud ต่อไปนี้
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
รัฐควรเป็น READY
ขั้นตอนที่ 3: รับการคาดการณ์และคำอธิบายเกี่ยวกับโมเดลที่ทำให้ใช้งานได้
เพื่อจุดประสงค์ในการอธิบาย เราให้ความสำคัญที่สุดในการอธิบายกรณีที่โมเดลของเราคาดการณ์ถึงการประพฤติมิชอบ เราจะส่งตัวอย่างทดสอบ 5 รายการไปยังโมเดลของเรา ซึ่งก็คือธุรกรรมที่ฉ้อโกงทั้งหมด
เราจะใช้ Google Cloud CLI เพื่อรับการคาดการณ์ เรียกใช้โค้ดต่อไปนี้เพื่อรับดัชนีตัวอย่างการฉ้อโกงทั้งหมดจากชุดทดสอบของเรา
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
ต่อไป เราจะบันทึกตัวอย่าง 5 ตัวอย่างในรูปแบบที่โมเดลของเราคาดหวัง และเขียนลงในไฟล์
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)
เราส่งตัวอย่าง 5 รายการต่อไปนี้ไปยังโมเดลของเราโดยใช้ gcloud ได้
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
ใน JSON ของการตอบกลับ คุณจะเห็นค่าการระบุแหล่งที่มาของแต่ละฟีเจอร์ในตัวอย่างเหล่านี้ คีย์ example_score สำหรับแต่ละตัวอย่างจะมีการคาดการณ์ของโมเดล ซึ่งในกรณีนี้เปอร์เซ็นต์ความเป็นไปได้ที่ธุรกรรมหนึ่งๆ จะเป็นการฉ้อโกง
8. ล้างข้อมูล
หากต้องการใช้สมุดบันทึกนี้ต่อไป ขอแนะนำให้ปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของสมุดบันทึกใน Cloud Console ให้เลือกสมุดบันทึก แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ในห้องทดลองนี้ เพียงลบอินสแตนซ์สมุดบันทึกแทนที่จะหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อเรียกดูพื้นที่เก็บข้อมูล แล้วลบที่เก็บข้อมูลทั้ง 2 รายการที่คุณสร้างขึ้นเพื่อจัดเก็บเนื้อหาโมเดล