1. ภาพรวม
ในแล็บนี้ คุณจะได้ใช้ AI Platform Notebooks เพื่อสร้างและฝึกโมเดลสำหรับการระบุธุรกรรมที่เป็นการประพฤติมิชอบ รวมถึงทำความเข้าใจการคาดการณ์ของโมเดลด้วย Explainable AI SDK การตรวจหาการประพฤติมิชอบเป็นการตรวจหาความผิดปกติประเภทหนึ่งที่เฉพาะเจาะจงสำหรับบริการทางการเงิน และทำให้โมเดล ML ต้องเผชิญกับความท้าทายที่น่าสนใจบางอย่าง ได้แก่ ชุดข้อมูลที่ไม่สมดุลโดยธรรมชาติ และความจำเป็นในการอธิบายผลลัพธ์ของโมเดล
สิ่งที่คุณจะได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- จัดการชุดข้อมูลที่ไม่สมดุล
- สร้างและประเมินโมเดลการตรวจหาการประพฤติมิชอบด้วย tf.keras ใน AI Platform Notebooks
- ใช้ Explainable AI SDK จากภายใน Notebook เพื่อทําความเข้าใจว่าเหตุใดโมเดลจึงจัดประเภทธุรกรรมว่าเป็นการประพฤติมิชอบ
- ทําให้โมเดลใช้งานได้ใน AI Platform พร้อมคําอธิบาย และรับการคาดการณ์และคําอธิบายเกี่ยวกับโมเดลที่ใช้งาน
ต้นทุนทั้งหมดในการเรียกใช้ Lab นี้ใน 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 แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook
ขั้นตอนที่ 3: สร้างอินสแตนซ์ AI Platform Notebooks
ไปที่ส่วน AI Platform Notebooks ใน Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.1 ที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
เมื่อเปิดอินสแตนซ์ ให้เลือกสมุดบันทึก Python 3 จากตัวเรียกใช้
ขั้นตอนที่ 4: นำเข้าแพ็กเกจ Python
สร้างเซลล์ใหม่และนำเข้าไลบรารีที่เราจะใช้ในโค้ดแล็บนี้
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 Notebook
!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 โดย DataFrame หนึ่งสำหรับธุรกรรมที่น่าสงสัยและอีก DataFrame หนึ่งสำหรับธุรกรรมที่ไม่น่าสงสัย (เราจะใช้ DataFrame นี้ในภายหลังใน Codelab เมื่อเราติดตั้งใช้งานโมเดล)
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
จากนั้นสุ่มตัวอย่างเคสที่ไม่ใช่การประพฤติมิชอบ เราใช้ 0.005% เนื่องจากจะทำให้เราแบ่งธุรกรรมที่เป็นการฉ้อโกง/ไม่ใช่การฉ้อโกงเป็น 25 / 75 ซึ่งจะช่วยให้คุณนำข้อมูลกลับมารวมกันและสับเปลี่ยนได้ เราจะนำคอลัมน์บางส่วนที่เราจะไม่ใช้ในการฝึกออกเพื่อลดความซับซ้อน
# 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')
*E. ก. Lopez-Rojas , A. Elmir และ S. Axelsson "PaySim: A financial mobile money simulator for fraud detection" In: The 28th European Modeling and Simulation Symposium-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 Sequential 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: แสดงภาพเมตริกของโมเดล
ตอนนี้เรามีโมเดลที่ฝึกแล้ว มาดูกันว่าโมเดลของเราทำงานได้ดีเพียงใดโดยการพล็อตเมตริกต่างๆ ตลอด Epoch การฝึก
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 มีเครื่องมือบางอย่างสำหรับการสร้างและพล็อตเมทริกซ์ความสับสน ซึ่งเราจะใช้ที่นี่
ที่จุดเริ่มต้นของ Notebook เราได้นำเข้ายูทิลิตี 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
SDK ของ Explainable AI มีเมธอดยูทิลิตีสำหรับการรับคำอธิบายเกี่ยวกับโมเดล โดยจะติดตั้งไว้ล่วงหน้าในอินสแตนซ์สมุดบันทึกของ AI Platform ที่ใช้ TensorFlow โปรดทราบว่าเราได้นำเข้าไลบรารีนี้ในสมุดบันทึกที่จุดเริ่มต้นของแล็บ SDK ช่วยให้เราได้รับการระบุแหล่งที่มาของฟีเจอร์จากโมเดลภายในอินสแตนซ์ Notebook ซึ่งหมายความว่าเราไม่จำเป็นต้องติดตั้งใช้งานโมเดลในระบบคลาวด์เพื่อใช้งาน
ในส่วนนี้ เราจะส่งออกโมเดลที่เพิ่งฝึกเป็น TensorFlow SavedModel แล้วชี้ SDK ไปยังชิ้นงานโมเดลที่บันทึกไว้เพื่อรับคำอธิบาย
ขั้นตอนที่ 1: ส่งออกโมเดลที่ฝึกแล้ว
ก่อนอื่น มาบันทึกโมเดลลงในไดเรกทอรีในอินสแตนซ์ Notebook กัน
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
หากรีเฟรชมุมมองโฟลเดอร์ในแถบด้านข้างซ้ายของ Notebook คุณจะเห็นไดเรกทอรีใหม่ชื่อ fraud_model/ ที่สร้างขึ้น
ขั้นตอนที่ 2: รับข้อมูลเมตาคำอธิบายด้วย SDK
จากนั้นเราจะชี้ SDK ของ Explainable AI ไปยังไดเรกทอรีนั้น การดำเนินการนี้จะสร้างข้อมูลเมตาที่จำเป็นสำหรับการรับคำอธิบายโมเดล เมธอด 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 เป็นพื้นฐานสำหรับค่าอินพุตแต่ละค่าที่โมเดลคาดหวัง ในกรณีการตรวจหาการประพฤติมิชอบ เราควรระบุเกณฑ์พื้นฐาน ซึ่งเราจะทำในส่วนต่อไปนี้
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 ใน Notebook ให้ไปที่ไดเรกทอรี fraud_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 จำนวนธุรกรรม ยอดคงเหลือในบัญชีปลายทาง และขั้นตอนเป็นตัวบ่งชี้ที่สำคัญรองลงมา ในชุดข้อมูล "step" หมายถึงหน่วยเวลา (1 step คือ 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)
)
คุณทำสิ่งต่างๆ ได้อีกมากมายด้วย Explainable AI ในโมเดลนี้ ตัวอย่างไอเดีย
- การส่งตัวอย่างจำนวนมากไปยังโมเดลของเราและหาค่าเฉลี่ยของค่าการระบุแหล่งที่มาเพื่อดูว่าฟีเจอร์บางอย่างมีความสำคัญมากกว่าโดยรวมหรือไม่ เราอาจใช้ข้อมูลนี้เพื่อปรับปรุงโมเดล และอาจนำฟีเจอร์ที่ไม่สำคัญออก
- การค้นหาผลบวกเท็จที่โมเดลของเราแจ้งว่าเป็นการฉ้อโกง แต่เป็นการทำธุรกรรมที่ไม่ใช่การฉ้อโกง และการตรวจสอบค่าการระบุแหล่งที่มา
- ใช้ค่าพื้นฐานอื่นและดูว่าค่านี้ส่งผลต่อมูลค่าการระบุแหล่งที่มาอย่างไร
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีพิจารณาข้อมูลที่ไม่สมดุล ฝึกโมเดล TensorFlow เพื่อตรวจหาธุรกรรมที่เป็นการฉ้อโกง และใช้ Explainable AI SDK เพื่อดูว่าฟีเจอร์ใดที่โมเดลของคุณใช้มากที่สุดในการคาดการณ์แต่ละรายการ คุณหยุดได้ที่นี่หากต้องการ การใช้ SDK ภายใน Notebook มีจุดประสงค์เพื่อลดความซับซ้อนของกระบวนการพัฒนาโมเดลโดยให้สิทธิ์เข้าถึงคำอธิบายก่อนที่จะนำโมเดลไปใช้งาน เมื่อสร้างโมเดลที่พอใจแล้ว คุณอาจต้องการนำไปใช้งานเพื่อรับการคาดการณ์ในวงกว้าง หากคุณเป็นผู้ใช้ดังกล่าว ให้ทำตามขั้นตอนถัดไปซึ่งเป็นขั้นตอนที่ไม่บังคับ หากเสร็จแล้ว ให้ข้ามไปยังขั้นตอนล้างข้อมูล
7. ไม่บังคับ: ทำให้โมเดลใช้งานได้กับ AI Platform Prediction
ในขั้นตอนนี้ คุณจะได้เรียนรู้วิธีการติดตั้งใช้งานโมเดลกับ AI Platform Prediction
ขั้นตอนที่ 1: คัดลอกไดเรกทอรีโมเดลที่บันทึกไว้ไปยัง Bucket ของ Cloud Storage
ขั้นตอน SDK ที่เราเรียกใช้ก่อนหน้านี้จะช่วยให้คุณมีทุกอย่างที่จำเป็นในการนำโมเดลไปใช้งานใน AI Platform หากต้องการเตรียมพร้อมสำหรับการติดตั้งใช้งาน คุณจะต้องวางชิ้นงาน SavedModel และข้อมูลเมตาของคำอธิบายไว้ใน Bucket ของ 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 นี้จากภายใน Notebook เพื่อสร้าง Bucket
!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 ของโมเดลที่บันทึกไว้และไฟล์ข้อมูลเมตา ปัจจุบัน Explainable AI มีวิธีการอธิบาย 2 วิธีที่แตกต่างกันสำหรับโมเดลแบบตาราง ในที่นี้เราใช้ 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. ล้างข้อมูล
หากต้องการใช้ Notebook นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Notebook ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ใน Lab นี้ เพียงลบอินสแตนซ์ Notebook แทนการหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่ Storage แล้วลบทั้ง 2 Bucket ที่คุณสร้างขึ้นเพื่อจัดเก็บชิ้นงานโมเดล