1. סקירה כללית
בשיעור ה-Lab הזה תשתמשו ב-notebooks של AI Platform כדי ליצור ולאמן מודל לזיהוי טרנזקציות שמקורן בתרמית, ולהבין את החיזויים של המודל באמצעות Explainable AI SDK. זיהוי הונאות הוא סוג של זיהוי אנומליות שהוא ספציפי לשירותים פיננסיים, ומציב בו כמה אתגרים מעניינים למודלים של למידת מכונה: מערכי נתונים לא מאוזנים מטבעם וצריך להסביר את התוצאות של המודל.
מה לומדים
נסביר לכם איך:
- טיפול במערכי נתונים לא מאוזנים
- פיתוח והערכה של מודל לזיהוי הונאות באמצעות tf.keras ב-notebooks של AI Platform
- אפשר להשתמש ב-Explainable AI SDK מתוך ה-notebook כדי להבין למה המודל מסווג עסקאות כעסקאות שמקורן בתרמית.
- פריסת המודל ב-AI Platform עם הסברים, וקבלת חיזויים והסברים לגבי המודל שנפרס
העלות הכוללת של הפעלת שיעור ה-Lab הזה ב-Google Cloud היא כ-$1.
2. למה כדאי לזהות הונאות?
זיהוי אנומליות יכול להיות כלי טוב ללמידת מכונה, כי לרוב קשה לכתוב סדרה של הצהרות מבוססות כללים כדי לזהות חריגים בנתונים. זיהוי הונאות הוא סוג של זיהוי אנומליות, ומציב שני אתגרים מעניינים בכל הנוגע ללמידת מכונה:
- מערכי נתונים לא מאוזנים מאוד: מכיוון שחריגות הן חריגות, אין הרבה מהן. למידת מכונה פועלת בצורה הטובה ביותר כשמערכי נתונים מאוזנים, כך שדברים יכולים להיות מורכבים יותר כשפחות מ-1% מהנתונים הם חריגים.
- נדרש הסבר על תוצאות: אם אתם מחפשים פעילות שמקורה בתרמית, סביר להניח שתרצו לדעת למה מערכת סימנה משהו כתרמית במקום להשתמש במילה. אפשר להיעזר בכלים של הסברים כדי לעשות זאת.
3. הגדרת הסביבה
כדי להריץ את ה-Codelab הזה צריך פרויקט ב-Google Cloud Platform שהחיוב מופעל בו. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.
שלב 1: הפעלת Cloud AI Platform Models API
עוברים לקטע 'מודלים של AI Platform במסוף Cloud ולוחצים על 'הפעלה' אם הוא עדיין לא מופעל.
שלב 2: מפעילים את Compute Engine API
עוברים אל Compute Engine ובוחרים באפשרות Enable (הפעלה) אם היא לא מופעלת עדיין. תצטרכו את הקישור הזה כדי ליצור מכונה של ה-notebook.
שלב 3: יצירת מכונה של AI Platform Notebooks
עוברים אל הקטע 'notebooks של AI Platform' במסוף Cloud ולוחצים על New Instance. לאחר מכן בוחרים בסוג המכונה TensorFlow Enterprise 2.1 ללא מעבדי GPU:
משתמשים באפשרויות ברירת המחדל ואז לוחצים על יצירה. אחרי שיוצרים את המכונה, בוחרים באפשרות Open JupyterLab:
כשפותחים את המכונה, בוחרים ב-notebook מסוג Python 3 במרכז האפליקציות:
שלב 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 הבאה ב-notebook של 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% שהיו לנו בעבר.
ראשית, מפצלים את הנתונים לשתי מסגרות DataFrames, אחת להונאה והשנייה ללא הונאה (נשתמש בה מאוחר יותר ב-Codelab כשנפרס את המודל שלנו):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 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')
*ה. א. לופז-רוחאס , א. Elmir, S. אקסלסון. "PaySim: סימולטור של כסף בנייד לאיתור הונאות". In: The 28 European Modeling and Simulation Symposium-EMSS, לרנקה, קפריסין. 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: קובעים את משקל הכיתה
בזמן הדגימה של הנתונים, עדיין רצינו לשמור על קבוצת משנה של העסקאות שלא שמקורן בתרמית, כך שלא איבדנו מידע על העסקאות האלה, ולכן לא ביצענו איזון מלא של הנתונים. מכיוון שמערך הנתונים עדיין לא מאוזן והכי חשוב לנו לזהות נכון עסקאות שמקורן בתרמית, אנחנו רוצים שהמודל שלנו יקצה יותר משקל לדוגמאות שמקורן בתרמית במערך הנתונים שלנו.
הפרמטר Keras class_weight מאפשר לציין את המשקל המדויק שרוצים לתת לדוגמאות מכל כיתה, על סמך התדירות שבה הן מופיעות במערך הנתונים:
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
לאחר מכן נגדיר כמה משתנים גלובליים לשימוש במהלך האימון, יחד עם פרמטרים של עצירה מוקדמת.
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 Learning יש כמה כלים ליצירה ולהצגה של מטריצות של בלבול, שבהן נשתמש כאן.
בתחילת ה-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. כאן מגדירים את הפונקציה:
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 העסקאות שמקורן בתרמית שבוצעו בקבוצת הבדיקות שלנו. שימו לב שהמיקוד בשיעור ה-Lab הזה הוא לא באיכות המודל. אם אתם פורסים מודל לזיהוי הונאות בסביבת הייצור, סביר להניח שתרצו ברמת דיוק גבוהה מ-85% של סיווג ההונאות. מטרת שיעור ה-Lab הזה היא להציג לכם את הכלים הדרושים להסבר על מודלים שאומנו על מערכי נתונים לא מאוזנים.
בשלב הבא נשתמש ב-Expplainable AI SDK כדי להבין על אילו תכונות המודל שלנו מסתמך כדי ליצור את החיזויים האלה.
6. שימוש ב-Expplainable AI SDK
ב-Explainable AI SDK תוכלו למצוא שיטות שימושיות לקבלת הסברים על המודל. הוא מותקן מראש במכונות של Tensorflow AI Platform – שימו לב שייבאנו אותו ל-notebook בתחילת שיעור ה-Lab. באמצעות ה-SDK אנחנו יכולים לקבל ייחוס של תכונות מהמודל שלנו במכונה של ה-notebook, כך שאנחנו לא צריכים לפרוס את המודל שלנו בענן כדי להשתמש בו.
בקטע הזה נייצא את המודל שאימנו עכשיו כ-Tensorflow SaveModel, ואז נפנה את ה-SDK לנכסי המודל השמורים כדי לקבל הסברים.
שלב 1: ייצוא של המודל שעבר אימון
קודם כל, נשמור את המודל שלנו בספרייה במכונת ה-notebook:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
אם תרעננו את תצוגת התיקיות בסרגל הצד השמאלי של ה-notebook, אמורה להופיע ספרייה חדשה בשם fraud_model/.
שלב 2: קבלת מטא-נתונים של הסברים באמצעות ה-SDK
בשלב הבא נצביע על הספרייה הזו את ערכת ה-SDK להסבר על AI. הפעולה הזו תיצור את המטא-נתונים שנחוצים לקבלת הסברים על המודל. ב-method get_metadata() מוצגים המטא-נתונים שה-SDK מסיקה מהמודל, כמו שמות הקלט:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
ההסבר עוזר לנו לענות על השאלה: "למה המודל שלנו חשב שזו הונאה?"
שלב 3: ציון ערכי הבסיס של המודל
בנתונים טבלאיים, שירות ה-AI להסבר פועל על ידי החזרת ערכי שיוך (Attribution) לכל תכונה. הערכים האלה מציינים עד כמה תכונה מסוימת השפיעה על החיזוי. נניח שהסכום של עסקה מסוימת גרם למודל שלנו להגדיל ב-0.2% את ההסתברות הצפויה להונאה של המודל. יכול להיות שתחשבו על '0.2% ביחס למה??'. זה מוביל אותנו לקונספט של ערך בסיסי.
הבסיס של המודל שלנו הוא בעצם מה שהוא משווה. אנחנו בוחרים את ערך הבסיס לכל תכונה במודל שלנו, וכתוצאה מכך, החיזוי הבסיסי הופך לערך שהמודל שלנו חוזים מתי התכונות מוגדרות בקבוצת הבסיס.
בחירת ערך הבסיס תלויה במשימת החיזוי שאתם פותרים. בתכונות מספריות, מקובל להשתמש בערך החציון של כל תכונה במערך הנתונים כערך הבסיס. עם זאת, במקרה של זיהוי הונאות, זה לא בדיוק מה שרצינו. הכי חשוב לנו להסביר את המקרים שבהם המודל שלנו מתייג עסקה כתרמית. כלומר, מקרה הבסיס שאנחנו רוצים להשוות אליו הוא עסקאות שלא עקב הונאה.
כדי לחשב זאת, נשתמש בערכים החציוניים של העסקאות שלא מתוך הונאה במערך הנתונים שלנו בתור ערך הבסיס. אפשר לקבל את החציון באמצעות ה-DataFrame not_fraud_sample שחילצנו למעלה, ולשנות את קנה המידה שלו כך שיתאים לקלט הצפוי מהמודל:
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, מנווטים לספרייה copyright_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. סכום העסקה, היתרה שהתקבלה בחשבון היעד והשלב הם המדדים המשמעותיים הבאים. במערך הנתונים, השלב מייצג יחידת זמן (שלב אחד הוא שעה אחת). גם ערכי השיוך יכולים להיות שליליים.
השגיאה 'שגיאת קירוב' שמודפס מעל להמחשה החזותית, מאפשר לכם לדעת עד כמה אפשר לסמוך על ההסבר. באופן כללי, המשמעות של שגיאה של יותר מ-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 כדי לזהות עסקאות שמקורן בתרמית ולהשתמש ב-SDK של Explainable AI כדי לבדוק על אילו תכונות המודל שלכם מסתמך הכי הרבה ליצירת חיזויים ספציפיים. אפשר לעצור כאן אם רוצים. שימוש ב-SDK בתוך notebook נועד לפשט את תהליך פיתוח המודל, באמצעות גישה להסברים לפני פריסת המודל. אם אתם יוצרים מודל שמתאים לכם, סביר להניח שתרצו לפרוס אותו כדי לקבל חיזויים בקנה מידה נרחב. אם זה מתאים לך, ממשיכים לשלב האופציונלי הבא. אם סיימתם, מדלגים לשלב ניקוי.
7. אופציונלי: פריסת המודל ב-AI Platform Prediction
בשלב הזה תלמדו איך לפרוס את המודל ב-AI Platform Prediction.
שלב 1: מעתיקים את ספריית המודלים השמורה לקטגוריה של Cloud Storage.
במסגרת שלבי ה-SDK שהפעלנו בעבר, יש לכם את כל מה שצריך כדי לפרוס את המודל ב-AI Platform. כדי להתכונן לפריסה, צריך לשים את הנכסים השמורים ב-SavedModel ואת המטא-נתונים של ההסברים בקטגוריה של Cloud Storage ששירות ה-AI Explainable יכול לקרוא.
כדי לעשות זאת, נגדיר כמה משתני סביבה. ממלאים את הערכים שלמטה עם שם הפרויקט ב-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 כדי ליצור קטגוריה:
!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. בבינה מלאכותית מוסברת יש כרגע שתי שיטות הסבר שונות שזמינות למודלים של טבלה. כאן אנחנו משתמשים ב-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)
אפשר לשלוח את חמש הדוגמאות האלה למודל שלנו באמצעות gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
בתשובה JSON תראו את ערכי השיוך של כל תכונה בדוגמאות האלה. המפתח example_score בכל דוגמה כולל את החיזוי של המודל – במקרה הזה, הסבירות שעסקה מסוימת תהיה שמקורה בתרמית.
8. הסרת המשאבים
אם ברצונך להמשיך להשתמש ב-notebook הזה, מומלץ להשבית אותו כשהוא לא בשימוש. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-notebook ואז לוחצים על Stop (עצירה):
כדי למחוק את כל המשאבים שיצרתם בשיעור ה-Lab הזה, תוכלו פשוט למחוק את המכונה של ה-notebook במקום לעצור אותה.
באמצעות תפריט הניווט במסוף Cloud, עוברים לקטע 'אחסון' ומוחקים את שתי הקטגוריות שיצרתם לצורך אחסון הנכסים של המודלים.