ইন্টিগ্রেটেড গ্রেডিয়েন্ট

TensorFlow.org-এ দেখুন

Google Colab-এ চালান

GitHub এ দেখুন

নোটবুক ডাউনলোড করুন

TF হাব মডেল দেখুন

এই টিউটোরিয়ালটি দেখায় কিভাবে ইন্টিগ্রেটেড গ্রেডিয়েন্ট (IG) প্রয়োগ করতে হয়, একটি ব্যাখ্যাযোগ্য AI কৌশল যা ডিপ নেটওয়ার্কের জন্য অ্যাক্সিওমেটিক অ্যাট্রিবিউশন পেপারে প্রবর্তিত হয়েছে। IG এর বৈশিষ্ট্যগুলির পরিপ্রেক্ষিতে একটি মডেলের ভবিষ্যদ্বাণীগুলির মধ্যে সম্পর্ক ব্যাখ্যা করা লক্ষ্য করে। এতে বৈশিষ্ট্যের গুরুত্ব বোঝা, ডেটা স্কু সনাক্ত করা এবং মডেল পারফরম্যান্স ডিবাগ করা সহ অনেকগুলি ব্যবহারের ক্ষেত্রে রয়েছে।

IG একটি জনপ্রিয় ব্যাখ্যাযোগ্যতা কৌশলে পরিণত হয়েছে যে কোন পার্থক্যযোগ্য মডেলের (যেমন ছবি, টেক্সট, স্ট্রাকচার্ড ডেটা), বাস্তবায়নের সহজতা, তাত্ত্বিক ন্যায্যতা এবং বিকল্প পদ্ধতির সাপেক্ষে গণনাগত দক্ষতা যা এটিকে বৃহৎ নেটওয়ার্ক এবং বৈশিষ্ট্যগুলিতে স্কেল করতে দেয়। স্পেস যেমন ছবি।

এই টিউটোরিয়ালে, আপনি একটি ইমেজ ক্লাসিফায়ারের পিক্সেল বৈশিষ্ট্যের গুরুত্ব বোঝার জন্য ধাপে ধাপে IG এর বাস্তবায়নের মধ্য দিয়ে যাবেন। একটি উদাহরণ হিসাবে, জলের জেট স্প্রে করা ফায়ারবোটের এই চিত্রটি বিবেচনা করুন৷ আপনি এই ছবিটিকে ফায়ারবোট হিসাবে শ্রেণীবদ্ধ করবেন এবং আপনার সিদ্ধান্তের জন্য গুরুত্বপূর্ণ হিসাবে নৌকা এবং জল কামানগুলি তৈরি করা পিক্সেলগুলিকে হাইলাইট করতে পারেন। আপনার মডেলটি এই টিউটোরিয়ালে পরে এই ছবিটিকে একটি ফায়ারবোট হিসাবে শ্রেণীবদ্ধ করবে; যাইহোক, এটি কি তার সিদ্ধান্ত ব্যাখ্যা করার সময় গুরুত্বপূর্ণ হিসাবে একই পিক্সেল হাইলাইট করে?

"আইজি অ্যাট্রিবিউশন মাস্ক" এবং "অরিজিনাল + আইজি মাস্ক ওভারলে" শিরোনামের নীচের চিত্রগুলিতে আপনি দেখতে পাচ্ছেন যে আপনার মডেলটি নৌকার জল কামান এবং জলের জেটগুলি সমন্বিত পিক্সেলগুলিকে (বেগুনি রঙে) তুলে ধরেছে যেগুলি নৌকার চেয়ে বেশি গুরুত্বপূর্ণ তার সিদ্ধান্ত। কিভাবে আপনার মডেল নতুন ফায়ারবোট সাধারণীকরণ হবে? জল জেট ছাড়া ফায়ারবোট সম্পর্কে কি? IG কীভাবে কাজ করে এবং কীভাবে তাদের ভবিষ্যদ্বাণী এবং অন্তর্নিহিত বৈশিষ্ট্যগুলির মধ্যে সম্পর্ক আরও ভালভাবে বুঝতে আপনার মডেলগুলিতে IG প্রয়োগ করতে হয় সে সম্পর্কে আরও জানতে পড়ুন।

সেটআপ

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

TF-Hub থেকে একটি পূর্বপ্রশিক্ষিত ইমেজ ক্লাসিফায়ার ডাউনলোড করুন

IG যেকোন ভিন্ন মডেলে প্রয়োগ করা যেতে পারে। আসল কাগজের আত্মায়, আপনি একই মডেলের একটি প্রাক-প্রশিক্ষিত সংস্করণ ব্যবহার করবেন, ইনসেপশন V1, যা আপনি টেনসরফ্লো হাব থেকে ডাউনলোড করবেন।

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
_________________________________________________________________

মডিউল পৃষ্ঠা থেকে, আপনাকে ইনসেপশন V1 সম্পর্কে নিম্নলিখিতগুলি মনে রাখতে হবে:

ইনপুট : মডেলের জন্য প্রত্যাশিত ইনপুট আকৃতি হল (None, 224, 224, 3) । এটি dtype float32 এবং আকৃতির (batch_size, height, width, RGB channels) এর একটি ঘন 4D টেনসর যার উপাদান হল RGB রঙের মান পিক্সেলের পরিসরে স্বাভাবিক করা হয়েছে [0, 1]। মডেল যে কোনো পূর্ণসংখ্যা ব্যাচের আকার নিতে পারে তা নির্দেশ করার জন্য প্রথম উপাদানটি None ।

আউটপুট : (batch_size, 1001) আকারে লগিটের একটি tf.Tensor . টেনসর। প্রতিটি সারি ইমেজনেট থেকে 1,001টি ক্লাসের প্রতিটির জন্য মডেলের পূর্বাভাসিত স্কোর উপস্থাপন করে। মডেলের শীর্ষ পূর্বাভাসিত শ্রেণী সূচকের জন্য আপনি 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 দিয়ে ছবি লোড এবং প্রিপ্রসেস করুন

আপনি উইকিমিডিয়া কমন্স থেকে দুটি ছবি ব্যবহার করে আইজিকে চিত্রিত করবেন: একটি ফায়ারবোট এবং একটি জায়ান্ট পান্ডা ।

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টি সবচেয়ে আত্মবিশ্বাসী ভবিষ্যদ্বাণী প্রদর্শন করে শুরু করি। শীর্ষ k পূর্বাভাসিত লেবেল এবং সম্ভাব্যতাগুলি পুনরুদ্ধার করার জন্য নিম্নলিখিত একটি ইউটিলিটি ফাংশন রয়েছে৷

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%

সমন্বিত গ্রেডিয়েন্ট গণনা করুন

আপনার মডেল, ইনসেপশন V1, একটি শেখা ফাংশন যা আপনার ইনপুট বৈশিষ্ট্য স্থান, ইমেজ পিক্সেল মান এবং 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)

fig = plt.figure(figsize=(12, 5))
ax0 = fig.add_subplot(121)
ax0.plot(x, f(x), marker='o')
ax0.set_title('Gradients saturate over F(x)', fontweight='bold')
ax0.text(0.2, 0.5, 'Gradients > 0 = \n x is important')
ax0.text(0.7, 0.85, 'Gradients = 0 \n x not important')
ax0.set_yticks(tf.range(0, 1.5, 0.5))
ax0.set_xticks(tf.range(0, 1.5, 0.5))
ax0.set_ylabel('F(x) - model true class predicted probability')
ax0.set_xlabel('x - (pixel value)')

ax1 = fig.add_subplot(122)
ax1.plot(x, f(x), marker='o')
ax1.plot(x, interpolated_path(x), marker='>')
ax1.set_title('IG intuition', fontweight='bold')
ax1.text(0.25, 0.1, 'Accumulate gradients along path')
ax1.set_ylabel('F(x) - model true class predicted probability')
ax1.set_xlabel('x - (pixel value)')
ax1.set_yticks(tf.range(0, 1.5, 0.5))
ax1.set_xticks(tf.range(0, 1.5, 0.5))
ax1.annotate('Baseline', xy=(0.0, 0.0), xytext=(0.0, 0.2),
             arrowprops=dict(facecolor='black', shrink=0.1))
ax1.annotate('Input', xy=(1.0, 0.0), xytext=(0.95, 0.2),
             arrowprops=dict(facecolor='black', shrink=0.1))
plt.show();

• বাম : পিক্সেল x এর জন্য আপনার মডেলের গ্রেডিয়েন্ট 0.0 এবং 0.8 এর মধ্যে ধনাত্মক কিন্তু 0.8 এবং 1.0 এর মধ্যে 0.0 এ যান। Pixel x স্পষ্টভাবে আপনার মডেলটিকে প্রকৃত শ্রেণীর 80% পূর্বাভাসিত সম্ভাবনার দিকে ঠেলে দেওয়ার ক্ষেত্রে একটি উল্লেখযোগ্য প্রভাব ফেলে। এটা কি বোঝায় যে পিক্সেল x এর গুরুত্ব ছোট বা অবিচ্ছিন্ন?

• ডান : IG এর পিছনে অন্তর্দৃষ্টি হল পিক্সেল x এর স্থানীয় গ্রেডিয়েন্টগুলি জমা করা এবং এটি আপনার মডেলের সামগ্রিক আউটপুট শ্রেণীর সম্ভাব্যতার সাথে কতটা যোগ বা বিয়োগ করে তার জন্য একটি স্কোর হিসাবে এর গুরুত্বকে দায়ী করা। আপনি 3 অংশে IG কে ভাঙ্গতে এবং গণনা করতে পারেন:

  1. 0 (একটি বেসলাইন বা প্রারম্ভিক বিন্দু) এবং 1 (ইনপুট পিক্সেলের মান) এর মধ্যে বৈশিষ্ট্যযুক্ত স্থানের একটি সরল রেখা বরাবর ছোট ছোট ধাপগুলি প্রসারিত করুন
  2. প্রতিটি ধাপে আপনার মডেলের ভবিষ্যদ্বাণীগুলির মধ্যে প্রতিটি ধাপে গ্রেডিয়েন্ট গণনা করুন
  3. এই স্থানীয় গ্রেডিয়েন্টগুলিকে (ক্রমবর্ধমান গড়) সঞ্চয় করে আপনার বেসলাইন এবং ইনপুটের মধ্যে অবিচ্ছেদ্য আনুমানিক।

এই অন্তর্দৃষ্টিকে শক্তিশালী করতে, আপনি নীচের উদাহরণ "ফায়ারবোট" চিত্রটিতে IG প্রয়োগ করে এই 3টি অংশের মধ্য দিয়ে যাবেন।

একটি বেসলাইন স্থাপন করুন

একটি বেসলাইন হল একটি ইনপুট চিত্র যা বৈশিষ্ট্যের গুরুত্ব গণনা করার জন্য একটি সূচনা বিন্দু হিসাবে ব্যবহৃত হয়। স্বজ্ঞাতভাবে, আপনি "ফায়ারবোট" ভবিষ্যদ্বাণীতে প্রতিটি পিক্সেলের অনুপস্থিতির প্রভাবের প্রতিনিধিত্বকারী হিসাবে বেসলাইনের ব্যাখ্যামূলক ভূমিকার কথা ভাবতে পারেন যাতে ইনপুট চিত্রে উপস্থিত থাকাকালীন "ফায়ারবোট" ভবিষ্যদ্বাণীতে প্রতিটি পিক্সেলের প্রভাবের বিপরীতে। ফলস্বরূপ, বেসলাইনের পছন্দটি পিক্সেল বৈশিষ্ট্যের গুরুত্ব ব্যাখ্যা করতে এবং ভিজ্যুয়ালাইজ করার ক্ষেত্রে একটি কেন্দ্রীয় ভূমিকা পালন করে। বেসলাইন নির্বাচনের অতিরিক্ত আলোচনার জন্য, এই টিউটোরিয়ালের নীচে "পরবর্তী পদক্ষেপ" বিভাগে সংস্থানগুলি দেখুন। এখানে, আপনি একটি কালো চিত্র ব্যবহার করবেন যার পিক্সেল মান সব শূন্য।

আপনি যে অন্যান্য পছন্দগুলির সাথে পরীক্ষা করতে পারেন তার মধ্যে রয়েছে একটি সম্পূর্ণ সাদা চিত্র, বা একটি এলোমেলো চিত্র, যা আপনি 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\) = রিম্যান সমষ্টির সমান্তরালে ধাপের সংখ্যা
\((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

একটি কালো বেসলাইন ইমেজ এবং উদাহরণ "ফায়ারবোট" ইমেজের মধ্যে আলফা ব্যবধানে একটি রৈখিক পথ বরাবর ইন্টারপোলেটেড ইমেজ তৈরি করতে উপরের ফাংশনটি ব্যবহার করা যাক।

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

টেনসরফ্লো আপনার জন্য একটি 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)

সঠিক আউটপুটের ক্ষেত্রে ইন্টারপোলেশন পাথ বরাবর প্রতিটি ছবির গ্রেডিয়েন্ট গণনা করা যাক। মনে রাখবেন যে আপনার মডেল লজিট সহ একটি (1, 1001) আকৃতির Tensor প্রদান করে যা আপনি প্রতিটি শ্রেণীর জন্য পূর্বাভাসিত সম্ভাব্যতায় রূপান্তর করেন। আপনার ছবির জন্য compute_gradients ফাংশনে আপনাকে সঠিক ImageNet টার্গেট ক্লাস ইনডেক্স পাস করতে হবে।

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)

গ্রেডিয়েন্ট স্যাচুরেশন ভিজ্যুয়ালাইজ করা

মনে রাখবেন যে গ্রেডিয়েন্টগুলি আপনি উপরে গণনা করেছেন তা আপনার মডেলের "ফায়ারবোট" এর পূর্বাভাসিত সম্ভাব্যতার স্থানীয় পরিবর্তনগুলি বর্ণনা করে এবং পরিপূর্ণ হতে পারে৷

নীচের 2টি প্লটে আপনি উপরে যে গ্রেডিয়েন্টগুলি গণনা করেছেন তা ব্যবহার করে এই ধারণাগুলি কল্পনা করা হয়েছে৷

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

plt.figure(figsize=(10, 4))
ax1 = plt.subplot(1, 2, 1)
ax1.plot(alphas, pred_proba)
ax1.set_title('Target class predicted probability over alpha')
ax1.set_ylabel('model p(target class)')
ax1.set_xlabel('alpha')
ax1.set_ylim([0, 1])

ax2 = plt.subplot(1, 2, 2)
# Average across interpolation steps
average_grads = tf.reduce_mean(path_gradients, axis=[1, 2, 3])
# Normalize gradients to 0 to 1 scale. E.g. (x - min(x))/(max(x)-min(x))
average_grads_norm = (average_grads-tf.math.reduce_min(average_grads))/(tf.math.reduce_max(average_grads)-tf.reduce_min(average_grads))
ax2.plot(alphas, average_grads_norm)
ax2.set_title('Average pixel gradients (normalized) over alpha')
ax2.set_ylabel('Average pixel gradients')
ax2.set_xlabel('alpha')
ax2.set_ylim([0, 1]);

• বাম : এই প্লটটি দেখায় কিভাবে "ফায়ারবোট" ক্লাসে আপনার মডেলের আস্থা আলফা জুড়ে পরিবর্তিত হয়। লক্ষ্য করুন কিভাবে রেখার গ্রেডিয়েন্ট, বা ঢাল, 0.6 এবং 1.0 এর মধ্যে বহুলাংশে চ্যাপ্টা বা সম্পৃক্ত হয় চূড়ান্ত "ফায়ারবোট"-এ স্থির হওয়ার আগে প্রায় 40% সম্ভাব্যতার পূর্বাভাস।

• ডান : ডান প্লটটি আলফার উপর গড় গ্রেডিয়েন্টের মাত্রা আরও সরাসরি দেখায়। লক্ষ্য করুন যে কীভাবে মানগুলি দ্রুত কাছে আসে এবং এমনকি সংক্ষিপ্তভাবে শূন্যের নীচে ডুবে যায়। প্রকৃতপক্ষে, আপনার মডেল সম্পৃক্ত হওয়ার আগে আলফার নিম্ন মানের গ্রেডিয়েন্ট থেকে সবচেয়ে বেশি "শিখে"৷ স্বজ্ঞাতভাবে, আপনি এটি ভাবতে পারেন কারণ আপনার মডেলটি সঠিক ভবিষ্যদ্বাণী করতে পিক্সেল যেমন জল কামান শিখেছে, এই পিক্সেল গ্রেডিয়েন্টগুলিকে শূন্যে পাঠিয়েছে, তবে এখনও বেশ অনিশ্চিত এবং আলফা মানগুলি কাছাকাছি আসার সাথে সাথে নকল ব্রিজ বা ওয়াটার জেট পিক্সেলগুলিতে ফোকাস করা হয়েছে। মূল ইনপুট ইমেজ।

এই গুরুত্বপূর্ণ জলকামান পিক্সেলগুলি "ফায়ারবোট" ভবিষ্যদ্বাণীতে গুরুত্বপূর্ণ হিসাবে প্রতিফলিত হয়েছে তা নিশ্চিত করতে, প্রতিটি পিক্সেল আপনার "ফায়ারবোট" ভবিষ্যদ্বাণীর সম্ভাব্যতাকে কীভাবে প্রভাবিত করে তা সঠিকভাবে আনুমানিকভাবে কীভাবে এই গ্রেডিয়েন্টগুলিকে একত্রিত করতে হয় তা শিখতে আপনি নীচে চালিয়ে যাবেন।

গ্রেডিয়েন্ট জমা করুন (অখণ্ড আনুমানিক)

বিভিন্ন ফাংশন জুড়ে নির্ভুলতা এবং অভিসারে বিভিন্ন ট্রেডঅফ সহ IG-এর জন্য একটি অখণ্ডের সংখ্যাসূচক অনুমান গণনা করার জন্য আপনি বিভিন্ন উপায়ে যেতে পারেন। পদ্ধতির একটি জনপ্রিয় শ্রেণীকে বলা হয় Riemann sums . এখানে, আপনি Trapezoidal নিয়ম ব্যবহার করবেন (আপনি এই টিউটোরিয়ালের শেষে বিভিন্ন আনুমানিক পদ্ধতি অন্বেষণ করতে অতিরিক্ত কোড খুঁজে পেতে পারেন)।

$IntegratedGrads^{প্রায়} {i}(x)::=(x {i}-x' {i})\times \overbrace{\sum {k=1}^{m} }^\text{Sum m local gradients} \text{gradients(interpolated images)} \times \overbrace{\frac{1}{m} }^\text{m steps দ্বারা ভাগ করুন}$

সমীকরণ থেকে, আপনি দেখতে পাচ্ছেন আপনি m গ্রেডিয়েন্টের উপর সমষ্টি করছেন এবং m ধাপ দিয়ে ভাগ করছেন। আপনি m ইন্টারপোলেটেড ভবিষ্যদ্বাণী এবং ইনপুট চিত্রগুলির স্থানীয় গ্রেডিয়েন্টের গড় হিসাবে অংশ 3-এর জন্য দুটি অপারেশন একসাথে বাস্তবায়ন করতে পারেন।

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 ইন্টারপোলেটেড ইমেজগুলির গ্রেডিয়েন্ট জুড়ে গড় একটি সমন্বিত গ্রেডিয়েন্ট টেনসর প্রদান করে যা আসল "জায়ান্ট পান্ডা" চিত্রের মতো একই আকার দেয়।

print(ig.shape)

(224, 224, 3)

সবগুলোকে একত্রে রাখ

এখন আপনি একটি IntegratedGradients গ্রেডিয়েন্ট ফাংশনে 3টি পূর্ববর্তী সাধারণ অংশগুলিকে একত্রিত করবেন এবং এটিকে একটি উচ্চ কার্যক্ষমতা কলযোগ্য টেনসরফ্লো গ্রাফে কম্পাইল করতে একটি @tf.function ডেকোরেটর ব্যবহার করবেন। এটি নীচে 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 বৈশিষ্ট্য বৈশিষ্ট্যগুলি ইনপুট "ফায়ারবোট" চিত্রের মতো একই আকৃতি রয়েছে৷

print(ig_attributions.shape)

(224, 224, 3)

পেপারটি উদাহরণের উপর নির্ভর করে 20 থেকে 300 এর মধ্যে ধাপের সংখ্যার পরামর্শ দেয় (যদিও বাস্তবে এটি 1,000 এর দশকে সঠিকভাবে অখণ্ডের আনুমানিক পরিমাণে বেশি হতে পারে)। আপনি এই টিউটোরিয়ালের শেষে "পরবর্তী পদক্ষেপ" সংস্থানগুলিতে যথাযথ সংখ্যক পদক্ষেপের জন্য পরীক্ষা করার জন্য অতিরিক্ত কোড খুঁজে পেতে পারেন।

বৈশিষ্ট্যগুলি কল্পনা করুন

আপনি অ্যাট্রিবিউশনগুলি কল্পনা করতে প্রস্তুত এবং সেগুলিকে মূল চিত্রের উপর ওভারলে করতে প্রস্তুত৷ নীচের কোডটি একটি অ্যাট্রিবিউশন মাস্ক তৈরি করতে রঙ চ্যানেল জুড়ে সমন্বিত গ্রেডিয়েন্টের পরম মানগুলি যোগ করে। এই প্লটিং পদ্ধতি মডেলের ভবিষ্যদ্বাণীতে পিক্সেলের আপেক্ষিক প্রভাব ক্যাপচার করে।

def plot_img_attributions(baseline,
                          image,
                          target_class_idx,
                          m_steps=50,
                          cmap=None,
                          overlay_alpha=0.4):

  attributions = integrated_gradients(baseline=baseline,
                                      image=image,
                                      target_class_idx=target_class_idx,
                                      m_steps=m_steps)

  # Sum of the attributions across color channels for visualization.
  # The attribution mask shape is a grayscale image with height and width
  # equal to the original image.
  attribution_mask = tf.reduce_sum(tf.math.abs(attributions), axis=-1)

  fig, axs = plt.subplots(nrows=2, ncols=2, squeeze=False, figsize=(8, 8))

  axs[0, 0].set_title('Baseline image')
  axs[0, 0].imshow(baseline)
  axs[0, 0].axis('off')

  axs[0, 1].set_title('Original image')
  axs[0, 1].imshow(image)
  axs[0, 1].axis('off')

  axs[1, 0].set_title('Attribution mask')
  axs[1, 0].imshow(attribution_mask, cmap=cmap)
  axs[1, 0].axis('off')

  axs[1, 1].set_title('Overlay')
  axs[1, 1].imshow(attribution_mask, cmap=cmap)
  axs[1, 1].imshow(image, alpha=overlay_alpha)
  axs[1, 1].axis('off')

  plt.tight_layout()
  return fig

"ফায়ারবোট" চিত্রের বৈশিষ্ট্যগুলি দেখে, আপনি দেখতে পাচ্ছেন যে মডেলটি জল কামান এবং স্পাউটগুলিকে তার সঠিক ভবিষ্যদ্বাণীতে অবদান হিসাবে চিহ্নিত করেছে৷

_ = 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)

ব্যবহার এবং সীমাবদ্ধতা

ব্যবহারের ক্ষেত্রে

• আপনার মডেল স্থাপন করার আগে ইন্টিগ্রেটেড গ্রেডিয়েন্টের মতো কৌশলগুলি নিযুক্ত করা আপনাকে এটি কীভাবে এবং কেন কাজ করে তার জন্য অন্তর্দৃষ্টি বিকাশে সহায়তা করতে পারে। এই কৌশল দ্বারা হাইলাইট বৈশিষ্ট্য আপনার অন্তর্দৃষ্টি মেলে? যদি তা না হয়, এটি আপনার মডেল বা ডেটাসেটে একটি বাগ বা ওভারফিটিং এর ইঙ্গিত হতে পারে।

সীমাবদ্ধতা

• ইন্টিগ্রেটেড গ্রেডিয়েন্টগুলি পৃথক উদাহরণগুলিতে বৈশিষ্ট্যের গুরুত্ব প্রদান করে, তবে এটি একটি সম্পূর্ণ ডেটাসেট জুড়ে বৈশ্বিক বৈশিষ্ট্যের গুরুত্ব প্রদান করে না।

• ইন্টিগ্রেটেড গ্রেডিয়েন্ট পৃথক বৈশিষ্ট্যের গুরুত্ব প্রদান করে, কিন্তু এটি বৈশিষ্ট্য মিথস্ক্রিয়া এবং সমন্বয় ব্যাখ্যা করে না।

পরবর্তী পদক্ষেপ

এই টিউটোরিয়ালটি ইন্টিগ্রেটেড গ্রেডিয়েন্টের একটি মৌলিক বাস্তবায়ন উপস্থাপন করেছে। পরবর্তী পদক্ষেপ হিসাবে, আপনি এই নোটবুকটি ব্যবহার করে বিভিন্ন মডেল এবং ছবি দিয়ে এই কৌশলটি ব্যবহার করতে পারেন।

আগ্রহী পাঠকদের জন্য, এই টিউটোরিয়ালটির একটি দীর্ঘ সংস্করণ রয়েছে (যার মধ্যে রয়েছে বিভিন্ন বেসলাইনের কোড, সমন্বিত অনুমান গণনা করা এবং পর্যাপ্ত সংখ্যক ধাপ নির্ধারণ করা) যা আপনি এখানে পেতে পারেন।

আপনার বোধগম্যতা আরও গভীর করতে, ডিপ নেটওয়ার্ক এবং গিথুব রিপোজিটরির জন্য অ্যাক্সিওমেটিক অ্যাট্রিবিউশন পেপারটি দেখুন, যেটিতে টেনসরফ্লো-এর পূর্ববর্তী সংস্করণে একটি বাস্তবায়ন রয়েছে। এছাড়াও আপনি distill.pub- এ বৈশিষ্ট্য অ্যাট্রিবিউশন এবং বিভিন্ন বেসলাইনের প্রভাব অন্বেষণ করতে পারেন।

বৈশিষ্ট্যের গুরুত্ব, মডেল ত্রুটি বিশ্লেষণ এবং ডেটা স্কু মনিটরিংয়ের জন্য আপনার প্রোডাকশন মেশিন লার্নিং ওয়ার্কফ্লোতে IG-কে অন্তর্ভুক্ত করতে আগ্রহী? Google ক্লাউডের ব্যাখ্যাযোগ্য AI পণ্যটি দেখুন যা IG অ্যাট্রিবিউশন সমর্থন করে। Google AI PAIR গবেষণা গোষ্ঠীও What-if টুলটি ওপেন সোর্স করেছে যা মডেল ডিবাগিংয়ের জন্য ব্যবহার করা যেতে পারে, যার মধ্যে IG বৈশিষ্ট্য বৈশিষ্ট্যগুলি ভিজ্যুয়ালাইজ করা রয়েছে।