شرح نموذج لرصد الاحتيال باستخدام Cloud AI Platform

1. نظرة عامة

في هذا التمرين، ستستخدم "دفاتر ملاحظات AI Platform" لإنشاء نموذج وتدريبه بهدف تحديد المعاملات الاحتيالية، وفهم توقّعات النموذج باستخدام حزمة تطوير البرامج (SDK) الخاصة بأداة الذكاء الاصطناعي القابل للتفسير. رصد الاحتيال هو نوع من رصد الحالات الشاذة خاص بالخدمات المالية، ويطرح بعض التحديات المثيرة للاهتمام لنماذج تعلُّم الآلة، مثل مجموعات البيانات غير المتوازنة بطبيعتها والحاجة إلى شرح نتائج النموذج.

ما ستتعرّف عليه

ستتعرَّف على كيفية:

التعامل مع مجموعات البيانات غير المتوازنة
إنشاء نموذج لرصد الاحتيال وتقييمه باستخدام tf.keras في دفاتر ملاحظات AI Platform
استخدِم حزمة تطوير البرامج (SDK) الخاصة بالذكاء الاصطناعي القابل للتفسير من داخل دفتر الملاحظات لفهم سبب تصنيف النموذج للمعاملات على أنّها احتيالية
نشر النموذج على AI Platform مع التفسيرات، والحصول على التوقعات والتفسيرات بشأن النموذج الذي تم نشره

يبلغ إجمالي تكلفة تشغيل هذا الدرس التطبيقي على Google Cloud حوالي 1 دولار أمريكي.

2. لماذا يجب رصد الاحتيال؟

يمكن أن تكون ميزة رصد القيم الشاذة خيارًا جيدًا لتعلُّم الآلة لأنّه غالبًا ما يصعب كتابة سلسلة من العبارات المستندة إلى قواعد لتحديد القيم الحدودية في البيانات. يُعدّ رصد الاحتيال أحد أنواع رصد الحالات الشاذة، ويطرح تحدّيين مثيرين للاهتمام عندما يتعلّق الأمر بتعلُّم الآلة:

مجموعات البيانات غير المتوازنة إلى حدّ كبير: بما أنّ القيم الشاذة هي، حسنًا، قيم شاذة، لا يوجد الكثير منها. تعمل خوارزميات تعلُّم الآلة بشكل أفضل عندما تكون مجموعات البيانات متوازنة، لذا قد تصبح الأمور معقّدة عندما تشكّل القيم المتطرفة أقل من% 1 من بياناتك.
الحاجة إلى شرح النتائج: إذا كنت تبحث عن نشاط احتيالي، من المحتمل أنّك تريد معرفة سبب تصنيف النظام لشيء ما على أنّه احتيالي بدلاً من الاكتفاء بتصنيفه. يمكن أن تساعد أدوات قابلية التفسير في ذلك.

3- إعداد البيئة

يجب أن يكون لديك مشروع على Google Cloud Platform مع تفعيل الفوترة لتتمكّن من تنفيذ هذا الدرس العملي. لإنشاء مشروع، اتّبِع التعليمات هنا.

الخطوة 1: تفعيل Cloud AI Platform Models API

انتقِل إلى قسم "AI Platform Models" في Cloud Console وانقر على "تفعيل" إذا لم تكن الميزة مفعَّلة بعد.

الخطوة 2: تفعيل واجهة برمجة التطبيقات Compute Engine API

انتقِل إلى Compute Engine وانقر على تفعيل إذا لم يكن مفعّلاً بعد. يجب توفير هذه المعلومات لإنشاء مثيل دفتر الملاحظات.

الخطوة 3: إنشاء مثيل AI Platform Notebooks

انتقِل إلى قسم "دفاتر ملاحظات AI Platform" في Cloud Console وانقر على إنشاء مثيل جديد. بعد ذلك، اختَر نوع مثيل TensorFlow Enterprise 2.1 بدون وحدات معالجة الرسومات:

استخدِم الخيارات التلقائية، ثم انقر على إنشاء. بعد إنشاء المثيل، انقر على فتح JupyterLab:

عند فتح المثيل، اختَر دفتر ملاحظات Python 3 من مشغّل التطبيقات:

الخطوة 4: استيراد حِزم Python

أنشئ خلية جديدة واستورِد المكتبات التي سنستخدمها في هذا الدرس العملي:

import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk

from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder

4. تنزيل البيانات ومعالجتها

سنستخدم مجموعة البيانات التي تم إنشاؤها بشكل اصطناعي من Kaggle لتدريب النموذج. تتضمّن مجموعة البيانات الأصلية 6.3 مليون صف، منها 8 آلاف صف يخصّ معاملات احتيالية، أي 0.1% فقط من مجموعة البيانات بأكملها.

الخطوة 1: تنزيل مجموعة بيانات Kaggle وقراءتها باستخدام Pandas

لقد أتحنا لك مجموعة بيانات 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 من البيانات.

لتقليل حجم مجموعة البيانات، سنأخذ كل الأمثلة الاحتيالية التي يبلغ عددها حوالي 8,000 مثال وعينة عشوائية من الحالات غير الاحتيالية التي يبلغ عددها حوالي 31,000 حالة. بهذه الطريقة، ستتضمّن مجموعة البيانات الناتجة% 25 من حالات الاحتيال، مقارنةً بنسبة% 0 .1 التي كانت لدينا من قبل.

أولاً، قسِّم البيانات إلى إطارَي بيانات، أحدهما لعمليات الاحتيال والآخر لعمليات غير الاحتيال (سنستفيد من ذلك لاحقًا في الدرس التطبيقي حول الترميز عند نشر النموذج):

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, and 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 في فئة الاحتيال. يهدف هذا الدرس التطبيقي إلى تعريفك بالأدوات المتاحة لشرح النماذج المدرَّبة على مجموعات بيانات غير متوازنة.

بعد ذلك، سنستخدم حزمة تطوير البرامج (SDK) الخاصة بـ الذكاء الاصطناعي القابل للتفسير لفهم الميزات التي يعتمد عليها نموذجنا لتقديم هذه التوقعات.

6. استخدام حزمة تطوير البرامج (SDK) الخاصة بالذكاء الاصطناعي القابل للتفسير

توفّر حزمة تطوير البرامج (SDK) الخاصة بالذكاء الاصطناعي القابل للتفسير طرقًا مساعدة للحصول على تفسيرات حول نموذجك. تكون هذه الحزمة مثبّتة مسبقًا في مثيلات Notebook في منصة Tensorflow AI Platform. يُرجى العِلم أنّنا استوردناها في دفتر الملاحظات في بداية التدريب العملي. باستخدام حزمة تطوير البرامج (SDK)، يمكننا الحصول على سمات الميزات من نموذجنا داخل مثيل دفتر الملاحظات، ما يعني أنّنا لسنا بحاجة إلى نشر نموذجنا على السحابة الإلكترونية لاستخدامه.

في هذا القسم، سنصدّر النموذج الذي درّبناه للتوّ كـ Tensorflow SavedModel، ثم نوجّه حزمة SDK إلى مواد عرض النموذج المحفوظ للحصول على التفسيرات.

الخطوة 1: تصدير النموذج المدرَّب

أولاً، لنحفظ النموذج في دليل في مثيل دفتر الملاحظات:

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

إذا أعدت تحميل عرض المجلد في الشريط الجانبي الأيمن من دفتر الملاحظات، من المفترض أن يظهر لك دليل جديد باسم fraud_model/ تم إنشاؤه.

الخطوة 2: الحصول على البيانات الوصفية الخاصة بالشرح باستخدام حزمة تطوير البرامج (SDK)

بعد ذلك، سنوجّه حزمة تطوير البرامج (SDK) الخاصة بميزة "الذكاء الاصطناعي القابل للتفسير" إلى هذا الدليل. سيؤدي ذلك إلى إنشاء البيانات الوصفية اللازمة للحصول على تفسيرات النموذج. تعرض الطريقة get_metadata() البيانات الوصفية التي تستنتجها حزمة تطوير البرامج (SDK) من نموذجك، مثل أسماء الإدخال:

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

تساعدنا إمكانية التفسير في الإجابة عن السؤال: "لماذا اعتقد نموذجنا أنّ هذه العملية احتيالية؟"

الخطوة 3: تحديد خط الأساس للنموذج

بالنسبة إلى البيانات الجدولية، تعمل خدمة الذكاء الاصطناعي القابل للتفسير من خلال عرض قيم تحديد المصدر لكل ميزة. تشير هذه القيم إلى مدى تأثير ميزة معيّنة في التوقّع. لنفترض أنّ مبلغ معاملة معيّنة أدّى إلى زيادة نموذجنا لاحتمالية الاحتيال المتوقّعة بنسبة %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) القيمة 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)
)

هناك الكثير من الإجراءات الأخرى التي يمكنك اتّخاذها باستخدام "الذكاء الاصطناعي القابل للتفسير" في هذا النموذج. تشمل بعض الأفكار ما يلي:

إرسال العديد من الأمثلة إلى نموذجنا وحساب متوسط قيم تحديد المصدر لمعرفة ما إذا كانت بعض الميزات أكثر أهمية بشكل عام يمكننا استخدام ذلك لتحسين نموذجنا، وربما إزالة الميزات غير المهمة.
العثور على نتائج إيجابية خاطئة يصنّفها نموذجنا على أنّها عمليات احتيال ولكنّها معاملات غير احتيالية، وفحص قيم تحديد المصدر الخاصة بها
استخدام خط أساس مختلف ومعرفة تأثير ذلك في قيم تحديد المصدر

🎉 تهانينا! 🎉

لقد تعلّمت كيفية تدوين سجلات الاستخدام للبيانات غير المتوازنة، وتدريب نموذج TensorFlow لرصد المعاملات الاحتيالية، واستخدام حزمة تطوير البرامج (SDK) الخاصة بأداة الذكاء الاصطناعي القابل للتفسير لمعرفة الميزات التي يعتمد عليها نموذجك بشكل أكبر لإجراء توقّعات فردية. يمكنك التوقف هنا إذا أردت. يهدف استخدام حزمة SDK في دفتر ملاحظات إلى تبسيط عملية تطوير النموذج من خلال منحك إمكانية الوصول إلى التفسيرات قبل نشر النموذج. بعد إنشاء نموذج مناسب، من المحتمل أنّك تريد نشره للحصول على توقّعات على نطاق واسع. إذا كان هذا الوصف ينطبق عليك، انتقِل إلى الخطوة التالية الاختيارية. إذا انتهيت من ذلك، انتقِل إلى خطوة التنظيف.

7. اختياري: نشر النموذج على AI Platform Prediction

في هذه الخطوة، ستتعرّف على كيفية نشر النموذج على AI Platform Prediction.

الخطوة 1: انسخ دليل النموذج المحفوظ إلى حزمة Cloud Storage.

باستخدام خطوات حزمة تطوير البرامج (SDK) التي نفّذناها سابقًا، يتوفّر لديك كل ما تحتاج إليه لنشر نموذجك على "منصة الذكاء الاصطناعي". للاستعداد لعملية التفعيل، عليك وضع مواد عرض SavedModel والبيانات الوصفية الخاصة بالتفسير في حزمة Cloud Storage يمكن أن تقرأها خدمة الذكاء الاصطناعي القابل للتفسير.

لإجراء ذلك، سنحدّد بعض متغيرات البيئة. املأ القيم أدناه باسم مشروعك على السحابة الإلكترونية واسم الحزمة التي تريد إنشاءها (يجب أن يكون الاسم فريدًا على مستوى العالم).

# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'

نحن الآن جاهزون لإنشاء حزمة تخزين لتخزين مواد عرض نموذج TensorFlow الذي تم تصديره. سنشير إلى هذا الحزمة في AI Platform عند نشر النموذج.

نفِّذ أمر 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، نمرّر موقع Cloud Storage الخاص بالنموذج المحفوظ وملف البيانات الوصفية. يتوفّر حاليًا في الذكاء الاصطناعي القابل للتفسير طريقتان مختلفتان للتفسير للنماذج الجدولية. نستخدم هنا طريقة Sampled Shapley. تشير المَعلمة num-paths إلى عدد المسارات التي تم أخذ عيّنات منها لكل ميزة إدخال. بشكل عام، كلما كان النموذج أكثر تعقيدًا، زادت خطوات التقريب اللازمة للوصول إلى تقارب معقول.

للتأكّد من نشر النموذج بشكل صحيح، نفِّذ أمر gcloud التالي:

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

يجب أن تكون الحالة READY.

الخطوة 3: الحصول على توقّعات وتفسيرات بشأن النموذج الذي تم نشره

لأغراض قابلية التفسير، نهتمّ بشكل أساسي بتفسير الحالات التي يتوقّع فيها نموذجنا حدوث عمليات احتيال. سنرسل 5 أمثلة اختبارية إلى نموذجنا، وكلها عبارة عن معاملات احتيالية.

سنستخدم واجهة سطر الأوامر (CLI) في Google Cloud للحصول على التوقعات. نفِّذ الرمز التالي للحصول على فهارس جميع أمثلة الاحتيال من مجموعة الاختبار:

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، اختَر دفتر الملاحظات، ثم انقر على إيقاف:

إذا أردت حذف جميع المراجع التي أنشأتها في هذا المختبر، ما عليك سوى حذف مثيل دفتر الملاحظات بدلاً من إيقافه.

باستخدام قائمة "التنقّل" في Cloud Console، انتقِل إلى "مساحة التخزين" واحذف الحزمتَين اللتين أنشأتهما لتخزين مواد عرض النموذج.