این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

توضیح مدل تشخیص تقلب با پلتفرم Cloud AI

۱. مرور کلی

در این آزمایشگاه، شما از نوت‌بوک‌های پلتفرم هوش مصنوعی برای ساخت و آموزش مدلی برای شناسایی تراکنش‌های جعلی استفاده خواهید کرد و پیش‌بینی‌های مدل را با کیت توسعه نرم‌افزاری هوش مصنوعی قابل توضیح (Explainable AI AI SDK) درک خواهید کرد. تشخیص تقلب نوعی تشخیص ناهنجاری خاص خدمات مالی است و چالش‌های جالبی را برای مدل‌های یادگیری ماشینی ارائه می‌دهد: مجموعه داده‌های ذاتاً نامتوازن و نیاز به توضیح نتایج مدل.

آنچه یاد می‌گیرید

شما یاد خواهید گرفت که چگونه:

مدیریت مجموعه داده‌های نامتوازن
ساخت و ارزیابی یک مدل تشخیص تقلب با tf.keras در نوت‌بوک‌های پلتفرم هوش مصنوعی
از کیت توسعه نرم‌افزار هوش مصنوعی Explainable AI SDK موجود در دفترچه یادداشت استفاده کنید تا بفهمید چرا مدل، تراکنش‌ها را به عنوان کلاهبرداری طبقه‌بندی کرده است.
مدل را به همراه توضیحات در پلتفرم هوش مصنوعی مستقر کنید و پیش‌بینی‌ها و توضیحات مربوط به مدل مستقر شده را دریافت کنید.

هزینه کل اجرای این آزمایشگاه در گوگل کلود حدود ۱ دلار است.

۲. چرا تشخیص تقلب؟

تشخیص ناهنجاری می‌تواند گزینه خوبی برای یادگیری ماشین باشد، زیرا اغلب نوشتن مجموعه‌ای از عبارات مبتنی بر قانون برای شناسایی داده‌های پرت در داده‌ها دشوار است. تشخیص تقلب نوعی تشخیص ناهنجاری است و دو چالش جالب را در یادگیری ماشین ارائه می‌دهد:

مجموعه داده‌های بسیار نامتوازن : از آنجا که ناهنجاری‌ها، خب، ناهنجاری هستند، تعداد زیادی از آنها وجود ندارد. یادگیری ماشینی زمانی بهترین عملکرد را دارد که مجموعه داده‌ها متعادل باشند، بنابراین وقتی داده‌های پرت کمتر از ۱٪ از داده‌های شما را تشکیل می‌دهند، اوضاع می‌تواند پیچیده شود.
نیاز به توضیح نتایج : اگر به دنبال فعالیت‌های کلاهبرداری هستید، احتمالاً می‌خواهید بدانید که چرا یک سیستم چیزی را به عنوان کلاهبرداری علامت‌گذاری کرده است، نه اینکه صرفاً حرف آن را بپذیرید. ابزارهای توضیح‌پذیری می‌توانند در این زمینه کمک کنند.

۳. محیط خود را راه‌اندازی کنید

برای اجرای این codelab به یک پروژه Google Cloud Platform با قابلیت پرداخت صورتحساب نیاز دارید. برای ایجاد یک پروژه، دستورالعمل‌های اینجا را دنبال کنید.

مرحله ۱: فعال کردن API مدل‌های پلتفرم هوش مصنوعی ابری

به بخش مدل‌های پلتفرم هوش مصنوعی در کنسول ابری خود بروید و اگر از قبل فعال نشده است، روی فعال کردن کلیک کنید.

مرحله ۲: فعال کردن رابط برنامه‌نویسی کاربردی موتور محاسبات

به Compute Engine بروید و اگر از قبل فعال نشده است، آن را فعال کنید . برای ایجاد نمونه نوت‌بوک خود به این مورد نیاز خواهید داشت.

مرحله ۳: ایجاد یک نمونه از نوت‌بوک‌های پلتفرم هوش مصنوعی

Navigate to AI Platform Notebooks section of your Cloud Console and click New Instance . Then select the TensorFlow Enterprise 2.1 instance type without GPUs :

از گزینه‌های پیش‌فرض استفاده کنید و سپس روی Create کلیک کنید. پس از ایجاد نمونه، Open JupyterLab را انتخاب کنید:

وقتی نمونه را باز می‌کنید، از لانچر، نوت‌بوک پایتون ۳ را انتخاب کنید:

مرحله ۴: وارد کردن بسته‌های پایتون

یک سلول جدید ایجاد کنید و کتابخانه‌هایی را که در این آزمایشگاه کد استفاده خواهیم کرد، وارد (import) کنید:

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

۴. دانلود و پردازش داده‌ها

ما از این مجموعه داده مصنوعی تولید شده از Kaggle برای آموزش مدل خود استفاده خواهیم کرد. مجموعه داده اصلی شامل ۶.۳ میلیون ردیف است که ۸ هزار عدد از آنها تراکنش‌های جعلی هستند - تنها ۰.۱٪ از کل مجموعه داده!

مرحله ۱: مجموعه داده Kaggle را دانلود کنید و با Pandas بخوانید

ما مجموعه داده Kaggle را در فضای ابری گوگل (Google Cloud Storage) برای شما در دسترس قرار داده‌ایم. می‌توانید با اجرای دستور gsutil زیر در نوت‌بوک ژوپیتر خود، آن را دانلود کنید:

!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .

در مرحله بعد، بیایید مجموعه داده را به عنوان یک قاب داده Pandas بخوانیم و پیش‌نمایشی از آن ارائه دهیم:

data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()

شما باید چیزی شبیه به این را در پیش‌نمایش ببینید:

مرحله ۲: در نظر گرفتن داده‌های نامتوازن

همانطور که در بالا ذکر شد، در حال حاضر مجموعه داده‌ها شامل ۹۹.۹٪ نمونه‌های غیرمتقلبانه است. اگر مدلی را بر اساس داده‌ها به همین صورت آموزش دهیم، احتمالاً مدل با حدس زدن اینکه هر تراکنش جعلی نیست، به دقت ۹۹.۹٪ خواهد رسید، صرفاً به این دلیل که ۹۹.۹٪ از داده‌ها موارد غیرمتقلبانه هستند.

چندین رویکرد مختلف برای مقابله با داده‌های نامتوازن وجود دارد. در اینجا، ما از تکنیکی به نام نمونه‌گیری کاهشی استفاده خواهیم کرد. نمونه‌گیری کاهشی به معنای استفاده از تنها درصد کمی از کلاس اکثریت در آموزش است. در این حالت، "غیر تقلب" کلاس اکثریت است زیرا 99.9٪ از داده‌ها را تشکیل می‌دهد.

برای نمونه‌برداری کوچک از مجموعه داده‌ها، تقریباً ۸ هزار نمونه از نمونه‌های متقلبانه و یک نمونه تصادفی تقریباً ۳۱ هزار موردی غیرمتقلبانه را در نظر می‌گیریم. به این ترتیب، مجموعه داده‌های حاصل ۲۵٪ موارد تقلب خواهد داشت، در مقایسه با ۰.۱٪ قبلی.

ابتدا، داده‌ها را به دو DataFrames تقسیم کنید، یکی برای موارد تقلب و دیگری برای موارد غیر تقلب (ما بعداً در آزمایشگاه کد، هنگام استقرار مدل خود از این استفاده خواهیم کرد):

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()

حالا ما یک مجموعه داده بسیار متعادل‌تر داریم. با این حال، اگر متوجه شویم که مدل ما در حدود دقت ۷۵٪ همگرا می‌شود، احتمال زیادی وجود دارد که در هر مورد «غیرتقلبی» را حدس بزند.

مرحله ۳: داده‌ها را به مجموعه‌های آموزش و آزمایش تقسیم کنید

آخرین کاری که قبل از ساخت مدل باید انجام دهیم، تقسیم داده‌ها است. ما از تقسیم‌بندی آموزش-آزمون ۸۰/۲۰ استفاده خواهیم کرد:

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')

*ای.ای. لوپز-روخاس، ای. المیر، و اس. اکسلسون. «PaySim: یک شبیه‌ساز پول موبایلی مالی برای تشخیص تقلب». در: بیست و هشتمین سمپوزیوم مدل‌سازی و شبیه‌سازی اروپا-EMSS، لارناکا، قبرس. ۲۰۱۶

۵. ساخت، آموزش و ارزیابی یک مدل tf.keras

ما با استفاده از API مربوط به tf.keras در TensorFlow مدل‌سازی خواهیم کرد. کد مدل در این بخش بر اساس این آموزش از مستندات TensorFlow ساخته شده است. ابتدا داده‌ها را نرمال‌سازی می‌کنیم و سپس مدل خود را با استفاده از پارامتر class_weight برای در نظر گرفتن عدم تعادل داده‌های باقی‌مانده، می‌سازیم و آموزش می‌دهیم.

مرحله ۱: نرمال‌سازی داده‌ها

هنگام آموزش یک مدل بر روی داده‌های عددی، نرمال‌سازی داده‌ها بسیار مهم است، به خصوص اگر هر ستون در محدوده متفاوتی قرار گیرد. این می‌تواند به جلوگیری از هدررفت داده‌ها در طول آموزش کمک کند. می‌توانیم داده‌های خود را با موارد زیر نرمال‌سازی کنیم:

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

مرحله ۲: تعیین وزن کلاس‌ها

هنگام نمونه‌برداری از داده‌ها، ما همچنان می‌خواستیم زیرمجموعه‌ای از تراکنش‌های غیرمتقلبانه را نگه داریم تا اطلاعات مربوط به آن تراکنش‌ها را از دست ندهیم، به همین دلیل است که داده‌ها را کاملاً متعادل نکردیم. از آنجا که مجموعه داده‌ها هنوز نامتعادل است و ما بیشتر به شناسایی صحیح تراکنش‌های جعلی اهمیت می‌دهیم، می‌خواهیم مدل ما وزن بیشتری به نمونه‌های جعلی در مجموعه داده‌های ما بدهد .

پارامتر 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}

ما از این متغیر هنگام آموزش مدل خود در مرحله بعدی استفاده خواهیم کرد.

مرحله ۳: آموزش و ارزیابی مدل

ما مدل خود را با استفاده از API مدل ترتیبی Keras خواهیم ساخت، که به ما امکان می‌دهد مدل خود را به عنوان پشته‌ای از لایه‌ها تعریف کنیم. تعدادی معیار وجود دارد که هنگام آموزش پیگیری می‌کنیم و به ما کمک می‌کنند تا بفهمیم مدل ما روی هر کلاس در مجموعه داده چگونه عمل می‌کند.

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)

آموزش چند دقیقه طول خواهد کشید تا اجرا شود.

مرحله ۴: معیارهای مدل را تجسم کنید

حالا که یک مدل آموزش‌دیده داریم، بیایید با رسم نمودارهای مختلف در طول دوره‌های آموزشی، عملکرد مدل خود را بررسی کنیم:

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)

نمودارهای شما باید شبیه به موارد زیر باشند (اما دقیقاً یکسان نخواهند بود):

مرحله ۵: چاپ ماتریس درهم‌ریختگی

ماتریس درهم‌ریختگی روشی خوب برای تجسم عملکرد مدل ما در مجموعه داده‌های آزمایشی است. برای هر کلاس، درصد نمونه‌های آزمایشی را که مدل ما به درستی و نادرست پیش‌بینی کرده است، به ما نشان می‌دهد. 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)

شما باید چیزی شبیه به این را ببینید (اعداد دقیق متفاوت خواهند بود):

در اینجا می‌توانیم ببینیم که مدل ما حدود ۸۵٪ از ۱۵۹۴ تراکنش جعلی را از مجموعه داده‌های آزمایشی ما به درستی پیش‌بینی کرده است. توجه داشته باشید که تمرکز در این آزمایشگاه بر کیفیت مدل نیست - اگر در حال پیاده‌سازی یک مدل تشخیص تقلب در محیط عملیاتی هستید، احتمالاً به دقتی بالاتر از ۸۵٪ در کلاس تقلب نیاز خواهید داشت. هدف این آزمایشگاه، آشنایی شما با ابزارهای مربوط به توضیح مدل‌های آموزش‌دیده روی مجموعه داده‌های نامتوازن است.

در مرحله بعد، از کیت توسعه نرم‌افزاری هوش مصنوعی Explainable برای درک اینکه مدل ما برای انجام این پیش‌بینی‌ها به کدام ویژگی‌ها متکی است، استفاده خواهیم کرد.

۶. استفاده از کیت توسعه نرم‌افزاری هوش مصنوعی Explainable

کیت توسعه نرم‌افزاری Explainable AI ، روش‌های کاربردی برای دریافت توضیحات در مورد مدل شما ارائه می‌دهد. این کیت به صورت پیش‌فرض در نمونه‌های Tensorflow AI Platform Notebook نصب شده است - توجه داشته باشید که ما آن را در ابتدای آزمایش خود در نوت‌بوک خود وارد کردیم. با استفاده از این کیت، می‌توانیم ویژگی‌های مدل خود را در نمونه نوت‌بوک دریافت کنیم، به این معنی که برای استفاده از آن نیازی به استقرار مدل در فضای ابری نداریم.

در این بخش، مدلی را که به تازگی آموزش داده‌ایم به عنوان یک Tensorflow SavedModel صادر می‌کنیم و سپس SDK را به سمت دارایی‌های مدل ذخیره شده خود هدایت می‌کنیم تا توضیحات را دریافت کنیم.

مرحله ۱: خروجی گرفتن از مدل آموزش‌دیده

ابتدا، مدل خود را در یک دایرکتوری در نمونه نوت‌بوک خود ذخیره می‌کنیم:

model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)

اگر نمای پوشه را در نوار کناری سمت چپ نوت‌بوک خود رفرش کنید، باید یک پوشه جدید به نام fraud_model/ ایجاد شده را ببینید.

مرحله ۲: دریافت فراداده‌های توضیحی با SDK

در مرحله بعد، ما کیت توسعه نرم‌افزاری Explainable AI را به آن دایرکتوری ارجاع می‌دهیم. انجام این کار، فراداده‌های لازم برای دریافت توضیحات مدل را ایجاد می‌کند. متد get_metadata() فراداده‌هایی را که SDK از مدل شما استنباط می‌کند، مانند نام‌های ورودی، نشان می‌دهد:

model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)

قابلیت توضیح به ما کمک می‌کند تا به این سوال پاسخ دهیم: «چرا مدل ما فکر کرد که این یک کلاهبرداری است؟»

مرحله ۳: مشخص کردن خط مبنای مدل

برای داده‌های جدولی، سرویس هوش مصنوعی Explainable با بازگرداندن مقادیر انتساب برای هر ویژگی کار می‌کند. این مقادیر نشان می‌دهند که یک ویژگی خاص چقدر بر پیش‌بینی تأثیر گذاشته است. فرض کنید مقدار یک تراکنش خاص باعث شده است که مدل ما احتمال تقلب پیش‌بینی‌شده خود را 0.2٪ افزایش دهد. ممکن است فکر کنید "0.2٪ نسبت به چه چیزی؟؟". این ما را به مفهوم خط پایه می‌رساند.

مبنای مدل ما اساساً همان چیزی است که با آن مقایسه می‌شود. ما مقدار مبنا را برای هر ویژگی در مدل خود انتخاب می‌کنیم و در نتیجه پیش‌بینی مبنا، مقداری می‌شود که مدل ما هنگام تنظیم ویژگی‌ها در مبنا پیش‌بینی می‌کند.

انتخاب یک مبنا به وظیفه پیش‌بینی که شما حل می‌کنید بستگی دارد. برای ویژگی‌های عددی، معمولاً از مقدار میانه هر ویژگی در مجموعه داده خود به عنوان مبنا استفاده می‌شود. با این حال، در مورد تشخیص تقلب، این دقیقاً همان چیزی نیست که ما می‌خواهیم. ما بیشتر به توضیح مواردی اهمیت می‌دهیم که مدل ما یک تراکنش را به عنوان کلاهبرداری برچسب‌گذاری می‌کند. این بدان معناست که مورد مبنا که می‌خواهیم با آن مقایسه کنیم، تراکنش‌های غیر کلاهبرداری است.

برای در نظر گرفتن این موضوع، از مقادیر میانه تراکنش‌های غیرمتقلبانه در مجموعه داده‌های خود به عنوان مبنا استفاده خواهیم کرد. می‌توانیم میانه را با استفاده از قاب داده 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 برای هر مقدار ورودی که مدل ما انتظار دارد، از عدد ۰ به عنوان خط پایه استفاده می‌کند. در مورد استفاده ما برای تشخیص تقلب، منطقی است که یک خط پایه مشخص کنیم، که در زیر انجام خواهیم داد:

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 برای تولید ویژگی‌های ویژگی از آنها استفاده خواهد کرد.

مرحله ۴: دریافت توضیحات مدل

اکنون آماده‌ایم تا ویژگی‌های مربوط به هر نمونه را دریافت کنیم. برای انجام این کار، ابتدا با استفاده از 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()

اجرای این دستور باید تصویری شبیه به تصویر زیر ایجاد کند:

در این مثال، موجودی اولیه حساب قبل از انجام تراکنش، بزرگترین شاخص کلاهبرداری بود که پیش‌بینی مدل ما را بیش از ۰.۵ از مقدار پایه بالاتر برد. مبلغ تراکنش، موجودی حاصل در حساب مقصد و گام، بزرگترین شاخص‌های بعدی بودند. در مجموعه داده‌ها، «گام» نشان دهنده یک واحد زمان است (هر گام ۱ ساعت است). مقادیر انتساب نیز می‌توانند منفی باشند.

«خطای تقریب» که بالای تصویرسازی‌ها چاپ می‌شود، به شما نشان می‌دهد که چقدر می‌توانید به توضیحات اعتماد کنید. به‌طورکلی، خطای بالای ۵٪ به این معنی است که ممکن است نتوانید به ویژگی‌های نسبت داده‌شده اعتماد کنید. به یاد داشته باشید که توضیحات شما فقط به خوبی داده‌های آموزشی و مدلی که استفاده کرده‌اید، هستند. بهبود داده‌های آموزشی، مدل یا امتحان کردن یک مدل پایه متفاوت می‌تواند خطای تقریب را کاهش دهد.

همچنین می‌توانید با افزایش تعداد مراحل استفاده شده در متد description خود، این خطا را کاهش دهید. می‌توانید این مورد را با SDK و با اضافه کردن پارامتر path_count به پیکربندی explanation خود تغییر دهید (اگر مشخص نکنید، مقدار پیش‌فرض ۱۰ است):

local_model = explainable_ai_sdk.load_model_from_local_path(
    model_dir, 
    explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)

کارهای بسیار بیشتری می‌توانید با استفاده از هوش مصنوعی قابل توضیح در این مدل انجام دهید. برخی از ایده‌ها عبارتند از:

ارسال نمونه‌های زیاد به مدل و میانگین‌گیری از مقادیر تخصیص برای بررسی اینکه آیا ویژگی‌های خاص در کل مهم‌تر هستند یا خیر. می‌توانیم از این روش برای بهبود مدل خود استفاده کنیم و به‌طور بالقوه ویژگی‌هایی را که مهم نیستند حذف کنیم.
یافتن موارد مثبت کاذب که مدل ما آنها را به عنوان کلاهبرداری علامت‌گذاری می‌کند اما تراکنش‌های غیرمتقلبانه هستند، و بررسی مقادیر انتساب آنها
از یک خط مبنای متفاوت استفاده کنید و ببینید که چگونه بر مقادیر انتساب تأثیر می‌گذارد

🎉 تبریک می‌گویم! 🎉

شما یاد گرفته‌اید که چگونه داده‌های نامتوازن را در نظر بگیرید، یک مدل TensorFlow را برای تشخیص تراکنش‌های جعلی آموزش دهید و از کیت توسعه نرم‌افزار هوش مصنوعی Explainable AI SDK استفاده کنید تا ببینید مدل شما برای پیش‌بینی‌های فردی بیشتر به کدام ویژگی‌ها متکی است. در صورت تمایل می‌توانید اینجا متوقف شوید. استفاده از کیت توسعه نرم‌افزار در یک دفترچه یادداشت به منظور ساده‌سازی فرآیند توسعه مدل شما با دسترسی به توضیحات قبل از استقرار مدل است. احتمالاً پس از ساخت مدلی که از آن راضی هستید، می‌خواهید آن را برای دریافت پیش‌بینی‌ها در مقیاس بزرگ مستقر کنید. اگر این موارد برای شما مناسب به نظر می‌رسد، به مرحله بعدی که اختیاری است بروید. اگر کارتان تمام شد، به مرحله پاکسازی بروید.

۷. اختیاری: مدل را در پیش‌بینی پلتفرم هوش مصنوعی مستقر کنید

در این مرحله، یاد خواهید گرفت که چگونه مدل خود را در پیش‌بینی پلتفرم هوش مصنوعی مستقر کنید.

مرحله ۱: دایرکتوری مدل ذخیره شده خود را در یک فضای ذخیره‌سازی ابری کپی کنید.

با مراحل SDK که قبلاً اجرا کردیم، شما هر آنچه را که برای استقرار مدل خود در پلتفرم هوش مصنوعی نیاز دارید، در اختیار دارید. برای آماده‌سازی برای استقرار، باید دارایی‌های SavedModel و فراداده‌های توضیحی خود را در یک سطل ذخیره‌سازی ابری قرار دهید که سرویس 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 اکسپورت شده خود ایجاد کنیم. هنگام استقرار مدل، پلتفرم هوش مصنوعی را به این مخزن ارجاع خواهیم داد.

برای ایجاد یک سطل، دستور gsutil را از داخل نوت‌بوک خود اجرا کنید:

!gsutil mb -l 'us-central1' $MODEL_BUCKET

سپس، دایرکتوری مدل محلی خود را در آن سطل کپی کنید:

!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations

مرحله ۲: استقرار مدل

در مرحله بعد، متغیرهایی را که در دستورات استقرار خود استفاده خواهیم کرد، تعریف خواهیم کرد:

MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'

ما می‌توانیم مدل را با دستور gcloud زیر ایجاد کنیم:

!gcloud ai-platform models create $MODEL --region=us-central1

اکنون آماده‌ایم تا اولین نسخه از این مدل را با gcloud مستقر کنیم. استقرار این نسخه حدود ۵ تا ۱۰ دقیقه طول خواهد کشید:

!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 ، محل ذخیره‌سازی ابری مدل ذخیره‌شده و فایل فراداده خود را وارد می‌کنیم. در حال حاضر، Explainable AI دو روش توضیح مختلف برای مدل‌های جدولی دارد. در اینجا ما از Sampled Shapley استفاده می‌کنیم. پارامتر num-paths تعداد مسیرهای نمونه‌برداری‌شده برای هر ویژگی ورودی را نشان می‌دهد. به‌طورکلی، هرچه مدل پیچیده‌تر باشد، برای رسیدن به همگرایی معقول، به مراحل تقریب بیشتری نیاز است.

برای تأیید استقرار صحیح مدل، دستور gcloud زیر را اجرا کنید:

!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1

ایالت باید READY باشد.

مرحله ۳: دریافت پیش‌بینی‌ها و توضیحات در مورد مدل پیاده‌سازی‌شده

برای اهداف توضیح‌پذیری، ما بیشتر به توضیح مواردی که مدل ما کلاهبرداری را پیش‌بینی می‌کند، اهمیت می‌دهیم. ما 5 نمونه آزمایشی را که همگی تراکنش‌های کلاهبرداری هستند، برای مدل خود ارسال خواهیم کرد.

ما از رابط خط فرمان گوگل کلود (Google Cloud CLI) برای دریافت پیش‌بینی‌ها استفاده خواهیم کرد. کد زیر را اجرا کنید تا شاخص‌های همه نمونه‌های کلاهبرداری را از مجموعه تست خود دریافت کنید:

fraud_indices = []

for i,val in enumerate(test_labels):
    if val == 1:
        fraud_indices.append(i)

در مرحله بعد، ۵ مثال را با فرمتی که مدل ما انتظار دارد ذخیره می‌کنیم و آنها را در یک فایل می‌نویسیم:

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 برای هر مثال شامل پیش‌بینی مدل است - در این مورد درصد احتمال اینکه یک تراکنش خاص جعلی باشد.

۸. پاکسازی

اگر می‌خواهید به استفاده از این دفترچه یادداشت ادامه دهید، توصیه می‌شود وقتی از آن استفاده نمی‌کنید، آن را خاموش کنید. از رابط کاربری دفترچه یادداشت‌ها در کنسول ابری خود، دفترچه یادداشت را انتخاب کرده و سپس توقف را انتخاب کنید:

اگر می‌خواهید تمام منابعی را که در این آزمایشگاه ایجاد کرده‌اید حذف کنید، به جای متوقف کردن آن، کافیست نمونه نوت‌بوک را حذف کنید.

با استفاده از منوی ناوبری در کنسول ابری خود، به بخش ذخیره‌سازی (Storage) بروید و هر دو باکتی را که برای ذخیره دارایی‌های مدل خود ایجاد کرده‌اید، حذف کنید.