הסבר על מודל לזיהוי הונאות באמצעות Cloud AI Platform

1. סקירה כללית

בשיעור ה-Lab הזה תשתמשו ב-AI Platform Notebooks כדי לבנות ולאמן מודל לזיהוי טרנזקציות שמקורן בתרמית, ותבינו את החיזויים של המודל באמצעות AI ניתן להסברה SDK. זיהוי הונאות הוא סוג של זיהוי אנומליות שספציפי לשירותים פיננסיים, והוא מציב כמה אתגרים מעניינים למודלים של למידת מכונה: מערכי נתונים לא מאוזנים באופן מובנה וצורך להסביר את התוצאות של המודל.

מה תלמדו

במאמר הזה נסביר איך:

טיפול במערכי נתונים לא מאוזנים
יצירה והערכה של מודל לזיהוי הונאות באמצעות tf.keras ב-AI Platform Notebooks
משתמשים ב- Explainable AI SDK מתוך המחברת כדי להבין למה המודל סיווג את העסקאות כתרמיות
פריסת המודל ב-AI Platform עם הסברים, וקבלת חיזויים והסברים על המודל שנפרס

העלות הכוללת להרצת ה-Lab הזה ב-Google Cloud היא בערך 1$‎.

‫2. למה צריך זיהוי הונאות?

זיהוי אנומליות הוא תחום מתאים ללמידת מכונה, כי לרוב קשה לכתוב סדרה של הצהרות מבוססות-כללים כדי לזהות ערכים חריגים בנתונים. זיהוי הונאות הוא סוג של זיהוי אנומליות, ויש בו שני אתגרים מעניינים בכל הנוגע ללמידת מכונה:

מערכי נתונים לא מאוזנים מאוד: חריגות הן חריגות, ולכן אין הרבה כאלה. הלמידה האוטומטית פועלת בצורה הטובה ביותר כשמערכי הנתונים מאוזנים, ולכן יכול להיות מסובך אם ערכים חריגים מהווים פחות מ-1% מהנתונים.
צריך להסביר את התוצאות: אם אתם מחפשים פעילות שמקורה בתרמית, סביר להניח שתרצו לדעת למה המערכת סימנה משהו כפעילות שמקורה בתרמית, ולא רק להסתמך על המילה שלה. כלים להסבר יכולים לעזור בכך.

‫3. הגדרת הסביבה

כדי להפעיל את ה-codelab הזה, צריך פרויקט ב-Google Cloud Platform שמופעל בו חיוב. כדי ליצור פרויקט, פועלים לפי ההוראות האלה.

שלב 1: הפעלת Cloud AI Platform Models API

עוברים אל AI Platform Models section במסוף Cloud ולוחצים על Enable אם הוא עדיין לא מופעל.

שלב 2: הפעלת Compute Engine API

עוברים אל Compute Engine ובוחרים באפשרות הפעלה אם הוא עדיין לא מופעל. תצטרכו את זה כדי ליצור את מופע המחברת.

שלב 3: יצירת מופע של מחברת AI Platform

עוברים אל AI Platform Notebooks section ב-Cloud Console ולוחצים על New Instance. לאחר מכן בוחרים את סוג האינסטנס TensorFlow Enterprise 2.1 without GPUs:

משתמשים באפשרויות ברירת המחדל ולוחצים על יצירה. אחרי שהמופע נוצר, בוחרים באפשרות 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 ב-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% מהנתונים הם מקרים לא הונאתיים.

יש כמה גישות שונות לטיפול בנתונים לא מאוזנים. במקרה הזה, נשתמש בטכניקה שנקראת דגימה חוזרת. דגימת חסר (Downsampling) פירושה שימוש רק באחוז קטן מהמקרים של המחלקה הגדולה ביותר באימון. במקרה הזה, 'לא הונאה' היא קבוצת הרוב כי היא מייצגת 99.9% מהנתונים.

כדי לבצע דגימת חסר של מערך הנתונים, ניקח את כל 8,000 הדוגמאות שמקורן בתרמית ומדגם אקראי של 31,000 מקרים שאינם תרמיות. כך, במערך הנתונים שיתקבל יהיו 25% מקרים של הונאה, לעומת 0 .1% שהיו לנו קודם.

קודם, מפצלים את הנתונים לשני אובייקטים מסוג 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')

*ה. א. Lopez-Rojas , A. Elmir ו-S. Axelsson. ‫PaySim: סימולטור פיננסי של כסף בנייד לזיהוי הונאות ‫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

לאחר מכן נגדיר כמה משתנים גלובליים לשימוש במהלך האימון, יחד עם כמה פרמטרים של עצירה מוקדמת.

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% בסיווג ההונאות. המטרה של שיעור ה-Lab הזה היא להציג לכם את הכלים להסבר של מודלים שאומנו על מערכי נתונים לא מאוזנים.

לאחר מכן נשתמש ב-SDK של AI ניתן להסברה כדי להבין על אילו תכונות המודל שלנו מסתמך כדי להפיק את התחזיות האלה.

6. שימוש ב-SDK של AI ניתן להסברה

‫Explainable AI SDK מספק שיטות עזר לקבלת הסברים על המודל. הוא מותקן מראש במופעי Notebook של AI Platform ב-Tensorflow – שימו לב שייבאנו אותו למחברת שלנו בתחילת שיעור ה-Lab. באמצעות ה-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: הגדרת בסיס למודל

במקרה של נתונים בטבלה, שירות ה-AI ניתן להסברה מחזיר ערכי ייחוס לכל תכונה. הערכים האלה מציינים עד כמה תכונה מסוימת השפיעה על התחזית. נניח שסכום עסקה מסוימת גרם למודל שלנו להגדיל את הסבירות החזויה להונאה ב-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. במחברת, עוברים לספרייה 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. הסכום של העסקה, היתרה בחשבון היעד והשלב היו האינדיקטורים הבאים בחשיבותם. בקבוצת הנתונים, 'שלב' מייצג יחידת זמן (שלב אחד הוא שעה אחת). ערכי השיוך יכולים להיות גם שליליים.

השגיאה המשוערת שמוצגת מעל התרשימים מאפשרת לכם לדעת עד כמה אפשר לסמוך על ההסבר. באופן כללי, שגיאה של יותר מ-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 של AI ניתן להסברה כדי לראות על אילו תכונות המודל מסתמך הכי הרבה כדי לבצע חיזויים פרטניים. אם רוצים, אפשר להפסיק כאן. השימוש ב-SDK בתוך מחברת נועד לפשט את תהליך פיתוח המודל, כי הוא מאפשר לכם לגשת להסברים לפני שאתם פורסים מודל. סביר להניח שאחרי שתבנו מודל שאתם מרוצים ממנו, תרצו לפרוס אותו כדי לקבל תחזיות בהיקף גדול. אם זה נשמע כמוך, אפשר להמשיך לשלב הבא (אופציונלי). אם סיימתם, דלגו לשלב ניקוי.

7. אופציונלי: פריסת המודל ב-AI Platform Prediction

בשלב הזה תלמדו איך לפרוס את המודל ב-AI Platform Prediction.

שלב 1: מעתיקים את ספריית המודל השמור לקטגוריה של Cloud Storage.

בעזרת השלבים של ה-SDK שהפעלנו קודם, יש לכם את כל מה שצריך כדי לפרוס את המודל ב-AI Platform. כדי להתכונן לפריסה, צריך להוסיף את נכסי SavedModel ואת מטא-נתוני ההסבר לקטגוריה של Cloud Storage ששירות ה-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 כדי ליצור קטגוריה:

!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 ניתן להסברה יש כרגע שתי שיטות הסבר שונות הזמינות עבור מודלים טבלאיים. בדוגמה הזו אנחנו משתמשים ב-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:

אם רוצים למחוק את כל המשאבים שיצרתם בסדנה הזו, פשוט מוחקים את מופע ה-Notebook במקום להפסיק אותו.

בתפריט הניווט ב-Cloud Console, עוברים אל Storage ומוחקים את שתי הקטגוריות שיצרתם כדי לאחסן את נכסי המודל.