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

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

1. بررسی اجمالی

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

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

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

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

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

2. چرا کشف تقلب؟

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

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

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

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

مرحله 1: Cloud AI Platforms Models API را فعال کنید

به بخش مدل‌های پلتفرم هوش مصنوعی در Cloud Console خود بروید و اگر قبلاً فعال نشده است روی Enable کلیک کنید.

مرحله ۲: Compute Engine API را فعال کنید

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

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

به بخش AI Platform Notebooks در Cloud Console خود بروید و روی New Instance کلیک کنید. سپس نوع نمونه TensorFlow Enterprise 2.1 را بدون GPU انتخاب کنید:

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

هنگامی که نمونه را باز می کنید، نوت بوک Python 3 را از راه اندازی انتخاب کنید:

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

یک سلول جدید ایجاد کنید و کتابخانه هایی را که در این کد لبه استفاده می کنیم وارد کنید:

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 هزار تای آن تراکنش های جعلی هستند - فقط 0.1٪ از کل مجموعه داده!

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

ما مجموعه داده Kaggle را در Google Cloud Storage برای شما در دسترس قرار داده ایم. با اجرای دستور gsutil زیر در نوت بوک Jupyter می توانید آن را دانلود کنید:

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

سپس، بیایید مجموعه داده را به عنوان یک Pandas DataFrame بخوانیم و پیش نمایش آن را مشاهده کنیم:

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

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

مرحله 2: حسابداری برای داده های نامتعادل

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

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

برای پایین‌آوری مجموعه داده‌هایمان، همه 8000 نمونه تقلبی و یک نمونه تصادفی از ~31k مورد غیر کلاهبرداری را انتخاب می‌کنیم. به این ترتیب مجموعه داده حاصل 25 درصد موارد کلاهبرداری خواهد داشت، در مقایسه با 0.1 درصدی که قبلاً داشتیم.

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

fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]

سپس، یک نمونه تصادفی از موارد غیر تقلب بردارید. ما از %005.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')

*EA Lopez-Rojas، A. Elmir و S. Axelsson. «PaySim: شبیه‌ساز پول موبایل مالی برای کشف کلاهبرداری». در: بیست و هشتمین سمپوزیوم اروپایی مدلسازی و شبیه سازی-EMSS، لارناکا، قبرس. 2016

5. یک مدل tf.keras بسازید، آموزش دهید و ارزیابی کنید

ما با استفاده از API tf.keras 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 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 درصد از 1594 تراکنش جعلی را از مجموعه آزمایشی ما به درستی پیش بینی کرده است. توجه داشته باشید که تمرکز در این آزمایشگاه بر روی کیفیت مدل نیست - اگر یک مدل تشخیص تقلب را در تولید به کار می‌گیرید، احتمالاً می‌خواهید دقت بالاتر از 85٪ در کلاس تقلب داشته باشید. هدف این آزمایشگاه این است که شما را با ابزارهایی پیرامون توضیح مدل های آموزش دیده بر روی مجموعه داده های نامتعادل آشنا کند.

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

6. استفاده از Explainable AI SDK

Explainable AI SDK روش های مفیدی را برای دریافت توضیحات در مورد مدل شما ارائه می دهد. این نوت بوک از پیش نصب شده است - توجه داشته باشید که ما آن را در ابتدای آزمایشگاه خود در نوت بوک خود وارد کردیم. با 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: تعیین خط پایه مدل ما

برای داده های جدولی، سرویس هوش مصنوعی توضیح پذیر با برگرداندن مقادیر انتساب برای هر ویژگی کار می کند. این مقادیر نشان می دهد که یک ویژگی خاص چقدر بر پیش بینی تأثیر گذاشته است. فرض کنید مقدار یک تراکنش خاص باعث شد مدل ما احتمال تقلب پیش‌بینی‌شده خود را 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 ایجاد شد. در نوت بوک خود، به دایرکتوری 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 افزایش داد. مقدار تراکنش، موجودی حاصل در حساب مقصد و مرحله، بزرگترین شاخص های بعدی بودند. در مجموعه داده، "گام" یک واحد زمان را نشان می دهد (1 مرحله 1 ساعت است). مقادیر انتساب نیز می تواند منفی باشد.

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

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

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

کارهای بیشتری می توانید با هوش مصنوعی توضیح پذیر در این مدل انجام دهید. برخی از ایده ها عبارتند از:

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

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

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

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

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

مرحله 1: دایرکتوری مدل ذخیره شده خود را در یک سطل ذخیره سازی ابری کپی کنید.

با مراحل SDK که قبلاً اجرا کردیم، همه چیزهایی را که برای استقرار مدل خود در پلتفرم هوش مصنوعی نیاز دارید در اختیار دارید. برای آماده شدن برای استقرار، باید دارایی های SavedModel و ابرداده های توضیحی خود را در یک سطل ذخیره سازی ابری قرار دهید که سرویس هوش مصنوعی توضیح پذیر بتواند آن را بخواند.

برای انجام این کار، چند متغیر محیطی را تعریف می کنیم. مقادیر زیر را با نام پروژه 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

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

اگر می خواهید به استفاده از این نوت بوک ادامه دهید، توصیه می شود در صورت عدم استفاده آن را خاموش کنید. از رابط کاربری Notebooks در Cloud Console خود، نوت بوک را انتخاب کنید و سپس Stop را انتخاب کنید:

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

با استفاده از منوی پیمایش در Cloud Console، به Storage بروید و هر دو سطل را که برای ذخیره دارایی های مدل خود ایجاد کرده اید حذف کنید.