تدرجات متكاملة

عرض على TensorFlow.org تشغيل في Google Colab عرض على جيثب تحميل دفتر انظر نموذج TF Hub

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

أصبح IG أسلوبًا شائعًا للتفسير نظرًا لإمكانية تطبيقه الواسع على أي نموذج مختلف (مثل الصور والنص والبيانات المهيكلة) ، وسهولة التنفيذ ، والمبررات النظرية ، والكفاءة الحسابية بالنسبة إلى الأساليب البديلة التي تسمح لها بالتوسع في الشبكات والميزات الكبيرة مسافات مثل الصور.

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

في الصور أدناه بعنوان "IG Attribution Mask" و "Original + IG Mask Overlay" ، يمكنك أن ترى أن نموذجك يبرز بدلاً من ذلك (باللون الأرجواني) وحدات البكسل التي تتألف من خراطيم المياه في القارب ونفاثات الماء باعتبارها أكثر أهمية من القارب نفسه بالنسبة قرارها. كيف سيتم تعميم نموذجك على الزوارق النارية الجديدة؟ ماذا عن زوارق الإطفاء بدون نفاثات مائية؟ تابع القراءة لمعرفة المزيد حول كيفية عمل IG وكيفية تطبيق IG على نماذجك لفهم العلاقة بين تنبؤاتهم والميزات الأساسية بشكل أفضل.

صورة الإخراج 1

يثبت

import matplotlib.pylab as plt
import numpy as np
import tensorflow as tf
import tensorflow_hub as hub

قم بتنزيل مصنف الصور الذي تم اختباره مسبقًا من TF-Hub

يمكن تطبيق IG على أي نموذج قابل للتفاضل. وفقًا لروح الورقة الأصلية ، ستستخدم إصدارًا تم تدريبه مسبقًا من نفس الطراز ، Inception V1 ، والذي ستقوم بتنزيله من TensorFlow Hub .

model = tf.keras.Sequential([
    hub.KerasLayer(
        name='inception_v1',
        handle='https://tfhub.dev/google/imagenet/inception_v1/classification/4',
        trainable=False),
])
model.build([None, 224, 224, 3])
model.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 inception_v1 (KerasLayer)   (None, 1001)              6633209   
                                                                 
=================================================================
Total params: 6,633,209
Trainable params: 0
Non-trainable params: 6,633,209
_________________________________________________________________

من صفحة الوحدة النمطية ، يجب أن تضع في اعتبارك ما يلي حول Inception V1:

المدخلات : شكل الإدخال المتوقع للنموذج هو (None, 224, 224, 3) . هذا موتر كثيف رباعي الأبعاد لـ dtype float32 والشكل (batch_size, height, width, RGB channels) التي تكون عناصرها عبارة عن قيم ألوان RGB للبكسل التي تم تسويتها إلى النطاق [0 ، 1]. العنصر الأول هو None للإشارة إلى أن النموذج يمكن أن يأخذ أي حجم دفعة عدد صحيح.

المخرجات : A tf Tensor of tf.Tensor in the شكل (batch_size, 1001) . يمثل كل صف الدرجة المتوقعة للنموذج لكل فئة من 1001 فئة من ImageNet. بالنسبة إلى أفضل فهرس للفئة المتوقعة للنموذج ، يمكنك استخدام tf.argmax(predictions, axis=-1) . علاوة على ذلك ، يمكنك أيضًا تحويل مخرجات السجل للنموذج إلى الاحتمالات المتوقعة عبر جميع الفئات باستخدام tf.nn.softmax(predictions, axis=-1) لتحديد عدم اليقين في النموذج وكذلك استكشاف الفئات المتوقعة المماثلة لتصحيح الأخطاء.

def load_imagenet_labels(file_path):
  labels_file = tf.keras.utils.get_file('ImageNetLabels.txt', file_path)
  with open(labels_file) as reader:
    f = reader.read()
    labels = f.splitlines()
  return np.array(labels)

imagenet_labels = load_imagenet_labels('https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')

تحميل الصور ومعالجتها مسبقًا باستخدام tf.image

سوف توضح IG باستخدام صورتين من ويكيميديا ​​كومنز : قارب نارية ، وباندا عملاق .

def read_image(file_name):
  image = tf.io.read_file(file_name)
  image = tf.io.decode_jpeg(image, channels=3)
  image = tf.image.convert_image_dtype(image, tf.float32)
  image = tf.image.resize_with_pad(image, target_height=224, target_width=224)
  return image

img_url = {
    'Fireboat': 'http://storage.googleapis.com/download.tensorflow.org/example_images/San_Francisco_fireboat_showing_off.jpg',
    'Giant Panda': 'http://storage.googleapis.com/download.tensorflow.org/example_images/Giant_Panda_2.jpeg',
}

img_paths = {name: tf.keras.utils.get_file(name, url) for (name, url) in img_url.items()}
img_name_tensors = {name: read_image(img_path) for (name, img_path) in img_paths.items()}

Downloading data from http://storage.googleapis.com/download.tensorflow.org/example_images/San_Francisco_fireboat_showing_off.jpg
3956736/3954129 [==============================] - 0s 0us/step
3964928/3954129 [==============================] - 0s 0us/step
Downloading data from http://storage.googleapis.com/download.tensorflow.org/example_images/Giant_Panda_2.jpeg
811008/802859 [==============================] - 0s 0us/step
819200/802859 [==============================] - 0s 0us/step

plt.figure(figsize=(8, 8))
for n, (name, img_tensors) in enumerate(img_name_tensors.items()):
  ax = plt.subplot(1, 2, n+1)
  ax.imshow(img_tensors)
  ax.set_title(name)
  ax.axis('off')
plt.tight_layout()

بي إن جي

تصنيف الصور

لنبدأ بتصنيف هذه الصور وعرض أكثر 3 تنبؤات ثقة. فيما يلي وظيفة مساعدة لاسترداد أفضل التسميات والاحتمالات المتوقعة.

def top_k_predictions(img, k=3):
  image_batch = tf.expand_dims(img, 0)
  predictions = model(image_batch)
  probs = tf.nn.softmax(predictions, axis=-1)
  top_probs, top_idxs = tf.math.top_k(input=probs, k=k)
  top_labels = imagenet_labels[tuple(top_idxs)]
  return top_labels, top_probs[0]

for (name, img_tensor) in img_name_tensors.items():
  plt.imshow(img_tensor)
  plt.title(name, fontweight='bold')
  plt.axis('off')
  plt.show()

  pred_label, pred_prob = top_k_predictions(img_tensor)
  for label, prob in zip(pred_label, pred_prob):
    print(f'{label}: {prob:0.1%}')

بي إن جي

fireboat: 32.6%
pier: 12.7%
suspension bridge: 5.7%

بي إن جي

giant panda: 89.4%
teddy: 0.3%
gibbon: 0.3%

حساب التدرجات المتكاملة

نموذجك ، Inception V1 ، عبارة عن وظيفة تم تعلمها تصف تعيينًا بين مساحة ميزة الإدخال وقيم بكسل الصورة ومساحة الإخراج المحددة بواسطة قيم احتمال فئة ImageNet بين 0 و 1. طرق تفسير مبكرة للشبكات العصبية التي تم تعيين درجات أهمية الميزة باستخدامها التدرجات اللونية ، والتي تخبرك بالبكسل التي لها أشد درجات الانحدار المحلية بالنسبة لتنبؤ النموذج الخاص بك في نقطة معينة على طول وظيفة التنبؤ الخاصة بنموذجك. ومع ذلك ، فإن التدرجات لا تصف سوى التغييرات المحلية في وظيفة التنبؤ بالنموذج الخاص بك فيما يتعلق بقيم البكسل ولا تصف بشكل كامل وظيفة التنبؤ بالنموذج بالكامل. نظرًا لأن نموذجك "يتعلم" تمامًا العلاقة بين نطاق البكسل الفردي وفئة ImageNet الصحيحة ، فإن التدرج اللوني لهذا البكسل سيتشبع ، مما يعني أن يصبح صغيراً بشكل متزايد بل ويذهب إلى الصفر. ضع في اعتبارك وظيفة النموذج البسيط أدناه:

def f(x):
  """A simplified model function."""
  return tf.where(x < 0.8, x, 0.8)

def interpolated_path(x):
  """A straight line path."""
  return tf.zeros_like(x)

x = tf.linspace(start=0.0, stop=1.0, num=6)
y = f(x)

بي إن جي

  • يسار : تدرجات نموذجك للبكسل x موجبة بين 0.0 و 0.8 لكنها تذهب إلى 0.0 بين 0.8 و 1.0. من الواضح أن Pixel x له تأثير كبير في دفع نموذجك نحو الاحتمال المتوقع بنسبة 80٪ على الفئة الحقيقية. هل يعقل أن أهمية البكسل x صغيرة أم متقطعة؟

  • صحيح : الحدس وراء IG هو تجميع التدرجات المحلية للبكسل x وإعطاء أهميتها كدرجة لمقدار ما تضيفه أو تنقصه من احتمالية فئة الإخراج الإجمالية لنموذجك. يمكنك تقسيم IG وحسابه في 3 أجزاء:

    1. أقحم الخطوات الصغيرة على طول خط مستقيم في مساحة الميزة بين 0 (خط أساسي أو نقطة بداية) و 1 (قيمة بكسل الإدخال)
    2. حساب التدرجات اللونية في كل خطوة بين تنبؤات النموذج الخاص بك فيما يتعلق بكل خطوة
    3. تقريب التكامل بين خط الأساس والمدخلات من خلال تجميع (متوسط ​​تراكمي) هذه التدرجات المحلية.

لتعزيز هذا الحدس ، سوف تتصفح هذه الأجزاء الثلاثة من خلال تطبيق IG على مثال صورة "Fireboat" أدناه.

إنشاء خط أساس

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

تشمل الخيارات الأخرى التي يمكنك تجربتها صورة بيضاء بالكامل ، أو صورة عشوائية ، والتي يمكنك إنشاؤها باستخدام tf.random.uniform(shape=(224,224,3), minval=0.0, maxval=1.0) .

baseline = tf.zeros(shape=(224,224,3))

plt.imshow(baseline)
plt.title("Baseline")
plt.axis('off')
plt.show()

بي إن جي

فك الصيغ في التعليمات البرمجية

معادلة التدرجات المتكاملة هي كما يلي:

\(IntegratedGradients_{i}(x) ::= (x_{i} - x'_{i})\times\int_{\alpha=0}^1\frac{\partial F(x'+\alpha \times (x - x'))}{\partial x_i}{d\alpha}\)

أين:

\(_{i}\) = خاصية
\(x\) = إدخال
\(x'\) = خط الأساس
\(\alpha\) = ثابت الاستيفاء لاضطراب الميزات بواسطة

من الناحية العملية ، فإن حساب التكامل المحدد ليس دائمًا ممكنًا عدديًا ويمكن أن يكون مكلفًا من الناحية الحسابية ، لذلك يمكنك حساب التقريب العددي التالي:

\(IntegratedGrads^{approx}_{i}(x)::=(x_{i}-x'_{i})\times\sum_{k=1}^{m}\frac{\partial F(x' + \frac{k}{m}\times(x - x'))}{\partial x_{i} } \times \frac{1}{m}\)

أين:

\(_{i}\) = ميزة (بكسل فردي)
\(x\) = إدخال (موتر الصورة)
\(x'\) = خط الأساس (موتر الصورة)
\(k\) = ثابت اضطراب السمة المقاس
\(m\) = عدد الخطوات في تقريب مجموع Riemann للتكامل
\((x_{i}-x'_{i})\) = مصطلح يشير إلى الاختلاف عن خط الأساس. هذا ضروري لتوسيع نطاق التدرجات المتكاملة والاحتفاظ بها من حيث الصورة الأصلية. يكون المسار من الصورة الأساسية إلى الإدخال بمساحة بكسل. نظرًا لأنك مع IG تقوم بالتكامل في خط مستقيم (تحويل خطي) ، ينتهي هذا الأمر بأن يكون مكافئًا تقريبًا للمصطلح المتكامل لمشتق دالة الصورة المقحمة فيما يتعلق بـ \(\alpha\) بخطوات كافية. يجمع التكامل مرات التدرج اللوني لكل بكسل التغيير في البكسل على طول المسار. من الأسهل تنفيذ هذا التكامل كخطوات منتظمة من صورة إلى أخرى ، مع استبدال \(x := (x' + \alpha(x-x'))\). لذا فإن تغيير المتغيرات يعطي \(dx = (x-x')d\alpha\). المصطلح \((x-x')\) ثابت ويتم أخرجه من التكامل.

أقحم الصور

\(IntegratedGrads^{approx}_{i}(x)::=(x_{i}-x'_{i})\times\sum_{k=1}^{m}\frac{\partial F(\overbrace{x' + \frac{k}{m}\times(x - x')}^\text{interpolate m images at k intervals})}{\partial x_{i} } \times \frac{1}{m}\)

أولاً ، ستقوم بإنشاء استيفاء خطي بين خط الأساس والصورة الأصلية. يمكنك التفكير في الصور المُقحمة كخطوات صغيرة في مساحة الميزة بين خط الأساس والإدخال ، ممثلة بـ \(\alpha\) في المعادلة الأصلية.

m_steps=50
alphas = tf.linspace(start=0.0, stop=1.0, num=m_steps+1) # Generate m_steps intervals for integral_approximation() below.

def interpolate_images(baseline,
                       image,
                       alphas):
  alphas_x = alphas[:, tf.newaxis, tf.newaxis, tf.newaxis]
  baseline_x = tf.expand_dims(baseline, axis=0)
  input_x = tf.expand_dims(image, axis=0)
  delta = input_x - baseline_x
  images = baseline_x +  alphas_x * delta
  return images

دعنا نستخدم الوظيفة المذكورة أعلاه لإنشاء صور محرفة على طول مسار خطي على فترات ألفا بين صورة أساسية سوداء ومثال صورة "Fireboat".

interpolated_images = interpolate_images(
    baseline=baseline,
    image=img_name_tensors['Fireboat'],
    alphas=alphas)

دعونا نتخيل الصور المحرف. ملاحظة: هناك طريقة أخرى للتفكير في ثابت \(\alpha\) وهي أنها تزيد باستمرار من شدة كل صورة محرفة.

fig = plt.figure(figsize=(20, 20))

i = 0
for alpha, image in zip(alphas[0::10], interpolated_images[0::10]):
  i += 1
  plt.subplot(1, len(alphas[0::10]), i)
  plt.title(f'alpha: {alpha:.1f}')
  plt.imshow(image)
  plt.axis('off')

plt.tight_layout();

بي إن جي

حساب التدرجات

الآن دعنا نلقي نظرة على كيفية حساب التدرجات من أجل قياس العلاقة بين التغييرات التي تطرأ على الميزة والتغييرات في تنبؤات النموذج. في حالة الصور ، يخبرنا التدرج اللوني أي البيكسلات لها التأثير الأقوى على النماذج المتوقعة احتمالات الطبقة.

\(IntegratedGrads^{approx}_{i}(x)::=(x_{i}-x'_{i})\times\sum_{k=1}^{m}\frac{\overbrace{\partial F(\text{interpolated images})}^\text{compute gradients} }{\partial x_{i} } \times \frac{1}{m}\)

أين:
\(F()\) = وظيفة التنبؤ الخاصة بنموذجك
\(\frac{\partial{F} }{\partial{x_i} }\) = التدرج اللوني (ناقل المشتقات الجزئية \(\partial\)) لوظيفة التنبؤ بالنموذج F الخاص بك بالنسبة لكل ميزة \(x_i\)

يجعل TensorFlow الحوسبة التدرجات سهلة بالنسبة لك باستخدام tf.GradientTape .

def compute_gradients(images, target_class_idx):
  with tf.GradientTape() as tape:
    tape.watch(images)
    logits = model(images)
    probs = tf.nn.softmax(logits, axis=-1)[:, target_class_idx]
  return tape.gradient(probs, images)

دعنا نحسب التدرجات لكل صورة على طول مسار الاستيفاء فيما يتعلق بالإخراج الصحيح. تذكر أن النموذج الخاص بك يُرجع Tensor (1, 1001) على شكل مع سجلات تقوم بتحويلها إلى احتمالات متوقعة لكل فئة. تحتاج إلى تمرير فهرس فئة الهدف compute_gradients الصحيح لوظيفة compute_gradients لصورتك.

path_gradients = compute_gradients(
    images=interpolated_images,
    target_class_idx=555)

لاحظ شكل الإخراج (n_interpolated_images, img_height, img_width, RGB) ، والذي يعطينا التدرج اللوني لكل بكسل من كل صورة على طول مسار الاستيفاء. يمكنك التفكير في هذه التدرجات على أنها قياس التغيير في تنبؤات نموذجك لكل خطوة صغيرة في مساحة الميزة.

print(path_gradients.shape)

(51, 224, 224, 3)

تصور تشبع التدرج

تذكر أن التدرجات اللونية التي حسبتها للتو تصف التغييرات المحلية على الاحتمال المتوقع لنموذجك لـ "Fireboat" ويمكن أن تتشبع .

يتم تصور هذه المفاهيم باستخدام التدرجات التي حسبتها أعلاه في المخططين أدناه.

pred = model(interpolated_images)
pred_proba = tf.nn.softmax(pred, axis=-1)[:, 555]

بي إن جي

  • يسار : يوضح هذا الرسم كيف تختلف ثقة نموذجك في فئة "Fireboat" عبر ألفا. لاحظ كيف أن التدرجات ، أو انحدار الخط ، يتم تسويته أو تشبعه إلى حد كبير بين 0.6 و 1.0 قبل الاستقرار في الاحتمالية النهائية "Fireboat" المتوقعة بحوالي 40٪.

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

للتأكد من أن هذه البكسلات المهمة لمدافع المياه تنعكس على أنها مهمة لتنبؤ "Fireboat" ، فستستمر في ما يلي لمعرفة كيفية تجميع هذه التدرجات لتقريب كيفية تأثير كل بكسل على الاحتمالية المتوقعة لـ Fireboat.

تراكم التدرجات (تقريب متكامل)

هناك العديد من الطرق المختلفة التي يمكنك اتباعها لحساب التقريب العددي لتكامل لـ IG مع مقايضات مختلفة في الدقة والتقارب عبر وظائف مختلفة. تسمى فئة الطرق الشائعة بمجموع ريمان . هنا ، ستستخدم قاعدة شبه المنحرف (يمكنك العثور على كود إضافي لاستكشاف طرق التقريب المختلفة في نهاية هذا البرنامج التعليمي).

$ IntegratedGrads ^ {almost} {i} (x) :: = (x {i} -x ' {i}) \ times \ overbrace {\ sum {k = 1} ^ {m}} ^ \ text {Sum m التدرجات المحلية} \ text {gradients (interpolated images)} \ times \ overbrace {\ frac {1} {m}} ^ \ text {Divide by m steps} $

من المعادلة ، يمكنك أن ترى أنك تجمع أكثر من m من التدرجات وتقسيمها على m من الخطوات. يمكنك تنفيذ العمليتين معًا للجزء 3 كمتوسط m المحلية للتنبؤات المحرفة والصور المدخلة .

def integral_approximation(gradients):
  # riemann_trapezoidal
  grads = (gradients[:-1] + gradients[1:]) / tf.constant(2.0)
  integrated_gradients = tf.math.reduce_mean(grads, axis=0)
  return integrated_gradients

تأخذ دالة integral_approximation تدرجات الاحتمال المتوقع للفئة المستهدفة فيما يتعلق بالصور المقحمة بين خط الأساس والصورة الأصلية.

ig = integral_approximation(
    gradients=path_gradients)

يمكنك تأكيد المتوسط ​​عبر التدرجات m للصور المحرفّة بإرجاع موتر تدرجات متكاملة بنفس شكل صورة "Giant Panda" الأصلية.

print(ig.shape)

(224, 224, 3)

ضع كل شيء معا

ستقوم الآن بدمج الأجزاء العامة الثلاثة السابقة معًا في دالة IntegratedGradients واستخدام مصمم @ tf.function لتجميعها في رسم بياني TensorFlow عالي الأداء قابل للاستدعاء. يتم تنفيذ ذلك في 5 خطوات أصغر أدناه:

\(IntegratedGrads^{approx}_{i}(x)::=\overbrace{(x_{i}-x'_{i})}^\text{5.}\times \overbrace{\sum_{k=1}^{m} }^\text{4.} \frac{\partial \overbrace{F(\overbrace{x' + \overbrace{\frac{k}{m} }^\text{1.}\times(x - x'))}^\text{2.} }^\text{3.} }{\partial x_{i} } \times \overbrace{\frac{1}{m} }^\text{4.}\)

  1. إنشاء alphas \(\alpha\)

  2. إنشاء صور محرف = \((x' + \frac{k}{m}\times(x - x'))\)

  3. حساب التدرجات بين تنبؤات الإخراج الخاصة بالنموذج \(F\) فيما يتعلق بميزات الإدخال = \(\frac{\partial F(\text{interpolated path inputs})}{\partial x_{i} }\)

  4. تقريب متكامل من خلال متوسط ​​التدرجات = \(\sum_{k=1}^m \text{gradients} \times \frac{1}{m}\)

  5. مقياس التدرجات المتكاملة فيما يتعلق بالصورة الأصلية = \((x_{i}-x'_{i}) \times \text{integrated gradients}\). السبب في ضرورة هذه الخطوة هو التأكد من أن قيم الإحالة المتراكمة عبر عدة صور محرفة هي في نفس الوحدات وتمثل بصدق استيراد وحدات البكسل على الصورة الأصلية.

def integrated_gradients(baseline,
                         image,
                         target_class_idx,
                         m_steps=50,
                         batch_size=32):
  # Generate alphas.
  alphas = tf.linspace(start=0.0, stop=1.0, num=m_steps+1)

  # Collect gradients.    
  gradient_batches = []

  # Iterate alphas range and batch computation for speed, memory efficiency, and scaling to larger m_steps.
  for alpha in tf.range(0, len(alphas), batch_size):
    from_ = alpha
    to = tf.minimum(from_ + batch_size, len(alphas))
    alpha_batch = alphas[from_:to]

    gradient_batch = one_batch(baseline, image, alpha_batch, target_class_idx)
    gradient_batches.append(gradient_batch)

  # Stack path gradients together row-wise into single tensor.
  total_gradients = tf.stack(gradient_batch)

  # Integral approximation through averaging gradients.
  avg_gradients = integral_approximation(gradients=total_gradients)

  # Scale integrated gradients with respect to input.
  integrated_gradients = (image - baseline) * avg_gradients

  return integrated_gradients

@tf.function
def one_batch(baseline, image, alpha_batch, target_class_idx):
    # Generate interpolated inputs between baseline and input.
    interpolated_path_input_batch = interpolate_images(baseline=baseline,
                                                       image=image,
                                                       alphas=alpha_batch)

    # Compute gradients between model outputs and interpolated inputs.
    gradient_batch = compute_gradients(images=interpolated_path_input_batch,
                                       target_class_idx=target_class_idx)
    return gradient_batch

ig_attributions = integrated_gradients(baseline=baseline,
                                       image=img_name_tensors['Fireboat'],
                                       target_class_idx=555,
                                       m_steps=240)

مرة أخرى ، يمكنك التحقق من أن سمات ميزة IG لها نفس شكل صورة الإدخال "Fireboat".

print(ig_attributions.shape)

(224, 224, 3)

تقترح الورقة عدد الخطوات التي تتراوح بين 20 إلى 300 اعتمادًا على المثال (على الرغم من أنه في الممارسة العملية يمكن أن يكون هذا أعلى في 1000s لتقريب التكامل بدقة). يمكنك العثور على رمز إضافي للتحقق من العدد المناسب من الخطوات في موارد "الخطوات التالية" في نهاية هذا البرنامج التعليمي.

تصور الصفات

أنت جاهز لتصور الإحالات وتراكبها على الصورة الأصلية. يجمع الكود أدناه القيم المطلقة للتدرجات المتكاملة عبر قنوات الألوان لإنتاج قناع إحالة. تلتقط طريقة الرسم هذه التأثير النسبي للبكسل على تنبؤات النموذج.

بالنظر إلى الخصائص الموجودة على صورة "Fireboat" ، يمكنك رؤية النموذج يحدد خراطيم المياه والصنابير كمساهمة في التنبؤ الصحيح.

_ = plot_img_attributions(image=img_name_tensors['Fireboat'],
                          baseline=baseline,
                          target_class_idx=555,
                          m_steps=240,
                          cmap=plt.cm.inferno,
                          overlay_alpha=0.4)

بي إن جي

في صورة "الباندا العملاقة" ، تُبرز السمات نسيج وجه الباندا وأنفها وفروها.

_ = plot_img_attributions(image=img_name_tensors['Giant Panda'],
                          baseline=baseline,
                          target_class_idx=389,
                          m_steps=55,
                          cmap=plt.cm.viridis,
                          overlay_alpha=0.5)

بي إن جي

الاستخدامات والقيود

استخدم حالات

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

محددات

  • توفر التدرجات المتكاملة عمليات استيراد للميزات في الأمثلة الفردية ، ومع ذلك ، فهي لا توفر عمليات استيراد عالمية للميزات عبر مجموعة بيانات كاملة.

  • توفر التدرجات المتكاملة ميزات فردية هامة ، لكنها لا تشرح التفاعلات والتركيبات الخاصة بالميزات.

الخطوات التالية

قدم هذا البرنامج التعليمي تنفيذًا أساسيًا للتدرجات المتكاملة. كخطوة تالية ، يمكنك استخدام هذا الكمبيوتر المحمول لتجربة هذه التقنية مع نماذج وصور مختلفة بنفسك.

للقراء المهتمين ، هناك إصدار أطول من هذا البرنامج التعليمي (والذي يتضمن رمزًا لخطوط أساسية مختلفة ، لحساب تقديرات تقريبية متكاملة ، ولتحديد عدد كافٍ من الخطوات) التي يمكنك العثور عليها هنا .

لتعميق فهمك ، تحقق من الورقة البحثية Attribution for Deep Networks و Github ، والتي تحتوي على تنفيذ في إصدار سابق من TensorFlow. يمكنك أيضًا استكشاف إحالة الميزة وتأثير الخطوط الأساسية المختلفة على distill.pub .

هل أنت مهتم بدمج IG في سير عمل التعلم الآلي للإنتاج لاستيراد الميزات وتحليل أخطاء النموذج ومراقبة انحراف البيانات؟ تحقق من منتج Google Cloud's Explainable AI الذي يدعم سمات IG. قامت مجموعة Google AI PAIR البحثية أيضًا بفتح أداة What-if التي يمكن استخدامها لتصحيح أخطاء النموذج ، بما في ذلك تصور سمات ميزات IG.