کیراس کی بیچ نارملائزیشن پرت ٹوٹ گئی ہے۔

• اپریل 17، 2018
• Vasilis Vryniotis
• . 30 تبصرے

اپ ڈیٹ: بدقسمتی سے کیراس سے میری پل کی درخواست جس نے بیچ نارملائزیشن پرت کے طرز عمل کو تبدیل کیا اسے قبول نہیں کیا گیا۔ آپ تفصیلات پڑھ سکتے ہیں۔ یہاں. آپ میں سے ان لوگوں کے لیے جو حسب ضرورت نفاذ کے ساتھ گڑبڑ کرنے کے لیے کافی بہادر ہیں، آپ کوڈ اس میں مل سکتے ہیں۔ میری شاخ. میں اسے برقرار رکھ سکتا ہوں اور اسے Keras کے تازہ ترین مستحکم ورژن کے ساتھ ضم کر سکتا ہوں (2.1.6, 2.2.2 اور 2.2.4) جب تک میں اسے استعمال کرتا ہوں لیکن کوئی وعدہ نہیں کرتا۔

ڈیپ لرننگ میں کام کرنے والے زیادہ تر لوگوں نے یا تو استعمال کیا ہے یا سنا ہے۔ کیراس. آپ میں سے ان لوگوں کے لیے جن کے پاس نہیں ہے، یہ ایک بہترین لائبریری ہے جو بنیادی ڈیپ لرننگ فریم ورک جیسے TensorFlow، Theano اور CNTK کا خلاصہ کرتی ہے اور اعلی سطحی API ANNs کی تربیت کے لیے۔ یہ استعمال کرنا آسان ہے، تیز رفتار پروٹو ٹائپنگ کو قابل بناتا ہے اور ایک دوستانہ فعال کمیونٹی ہے۔ میں کافی عرصے سے اس کا بہت زیادہ استعمال کر رہا ہوں اور وقتاً فوقتاً اس پروجیکٹ میں حصہ ڈال رہا ہوں اور میں یقینی طور پر ہر اس شخص کو تجویز کرتا ہوں جو ڈیپ لرننگ پر کام کرنا چاہتا ہے۔

اگرچہ کیراس نے میری زندگی کو آسان بنا دیا، کئی بار مجھے بیچ نارملائزیشن پرت کے عجیب و غریب رویے سے کاٹا گیا ہے۔ وقت کے ساتھ ساتھ اس کا ڈیفالٹ رویہ بدل گیا ہے، اس کے باوجود یہ اب بھی بہت سے صارفین کے لیے مسائل کا باعث بنتا ہے اور اس کے نتیجے میں کئی متعلقہ کھلے مسائل گیتھب پر۔ اس بلاگ پوسٹ میں، میں ایک کیس بنانے کی کوشش کروں گا کہ کیوں کیراس کی بیچ نارملائزیشن پرت ٹرانسفر لرننگ کے ساتھ اچھی نہیں چلتی، میں وہ کوڈ فراہم کروں گا جو اس مسئلے کو حل کرتا ہے اور میں مثالیں دوں گا پیچ.

ذیل کے ذیلی حصوں پر، میں ایک تعارف فراہم کرتا ہوں کہ ڈیپ لرننگ میں ٹرانسفر لرننگ کا استعمال کیسے کیا جاتا ہے، بیچ نارملائزیشن لیئر کیا ہے، سیکھنے کا مرحلہ کیسے کام کرتا ہے اور کیراس نے وقت کے ساتھ ساتھ BN کے رویے کو کیسے تبدیل کیا۔ اگر آپ یہ پہلے سے جانتے ہیں، تو آپ محفوظ طریقے سے براہ راست سیکشن 2 پر جا سکتے ہیں۔

1.1 ڈیپ لرننگ کے لیے ٹرانسفر لرننگ کا استعمال بہت ضروری ہے۔

ماضی میں ڈیپ لرننگ پر تنقید کی ایک وجہ یہ ہے کہ اس کے لیے بہت زیادہ ڈیٹا کی ضرورت ہوتی ہے۔ یہ ہمیشہ سچ نہیں ہوتا ہے۔ اس حد کو دور کرنے کے لیے کئی تکنیکیں ہیں، جن میں سے ایک ٹرانسفر لرننگ ہے۔

فرض کریں کہ آپ کمپیوٹر وژن ایپلی کیشن پر کام کر رہے ہیں اور آپ ایک ایسا درجہ بندی بنانا چاہتے ہیں جو بلیوں کو کتوں سے ممتاز کرے۔ ماڈل کو تربیت دینے کے لیے آپ کو درحقیقت لاکھوں بلی/کتے کی تصاویر کی ضرورت نہیں ہے۔ اس کے بجائے آپ پہلے سے تربیت یافتہ کلاسیفائر استعمال کر سکتے ہیں اور کم ڈیٹا کے ساتھ ٹاپ کنولیشنز کو ٹھیک کر سکتے ہیں۔ اس کے پیچھے خیال یہ ہے کہ چونکہ پہلے سے تربیت یافتہ ماڈل امیجز پر فٹ تھا، اس لیے نچلی شکلیں لائنوں، کناروں اور دیگر مفید نمونوں جیسی خصوصیات کو پہچان سکتی ہیں یعنی آپ اس کے وزن کو یا تو اچھی ابتدائی اقدار کے طور پر استعمال کر سکتے ہیں یا اپنے ڈیٹا کے ساتھ نیٹ ورک کو جزوی طور پر دوبارہ تربیت دے سکتے ہیں۔ .

Keras کئی پہلے سے تربیت یافتہ ماڈلز اور استعمال میں آسان مثالوں کے ساتھ آتا ہے کہ ماڈلز کو کیسے ٹھیک کیا جائے۔ آپ پر مزید پڑھ سکتے ہیں۔ دستاویزات.

1.2 بیچ نارملائزیشن پرت کیا ہے؟

بیچ نارملائزیشن پرت کو Ioffe اور Szegedy نے 2014 میں متعارف کرایا تھا۔ یہ پچھلی پرت کے آؤٹ پٹ کو معیاری بنا کر غائب ہونے والے تدریجی مسئلے کو حل کرتا ہے، یہ مطلوبہ تکرار کی تعداد کو کم کرکے تربیت کو تیز کرتا ہے اور یہ گہرے اعصابی نیٹ ورکس کی تربیت کو قابل بناتا ہے۔ یہ بتانا کہ یہ کیسے کام کرتا ہے اس پوسٹ کے دائرہ کار سے باہر ہے لیکن میں آپ کو پڑھنے کی بھرپور حوصلہ افزائی کرتا ہوں۔ اصل کاغذ. ایک حد سے زیادہ آسان وضاحت یہ ہے کہ یہ ان پٹ کو اس کے اوسط کو گھٹا کر اور اس کے معیاری انحراف کے ساتھ تقسیم کرکے دوبارہ اسکیل کرتا ہے۔ اگر ضروری ہو تو یہ تبدیلی کو کالعدم کرنا بھی سیکھ سکتا ہے۔

1.3 کیراس میں سیکھنے کا مرحلہ کیا ہے؟

ٹریننگ اور انفرنس موڈ کے دوران کچھ پرتیں مختلف طریقے سے کام کرتی ہیں۔ سب سے قابل ذکر مثالیں بیچ نارملائزیشن اور ڈراپ آؤٹ لیئرز ہیں۔ BN کے معاملے میں، ٹریننگ کے دوران ہم ان پٹ کو ری سکیل کرنے کے لیے منی بیچ کے وسط اور تغیر کا استعمال کرتے ہیں۔ دوسری طرف، قیاس کے دوران ہم متحرک اوسط اور تغیر کا استعمال کرتے ہیں جس کا تخمینہ تربیت کے دوران لگایا گیا تھا۔

کیراس جانتا ہے کہ کس موڈ میں چلنا ہے کیونکہ اس میں بلٹ ان میکانزم ہے جسے کہتے ہیں۔ سیکھنے کا_مرحلہ. سیکھنے کا مرحلہ کنٹرول کرتا ہے کہ نیٹ ورک ٹرین پر ہے یا ٹیسٹ موڈ پر۔ اگر اسے صارف کے ذریعہ دستی طور پر سیٹ نہیں کیا گیا ہے، فٹ() کے دوران نیٹ ورک learning_phase=1 (ٹرین موڈ) کے ساتھ چلتا ہے۔ پیشین گوئیاں تیار کرتے وقت (مثال کے طور پر جب ہم predict() & evaluate() طریقوں کو کہتے ہیں یا fit()) کے توثیق کے مرحلے پر نیٹ ورک learning_phase=0 (ٹیسٹ موڈ) کے ساتھ چلتا ہے۔ اگرچہ اس کی سفارش نہیں کی جاتی ہے، صارف سیکھنے کے مرحلے کو مستحکم طور پر ایک مخصوص قدر میں تبدیل کرنے کے قابل بھی ہے لیکن گراف میں کسی بھی ماڈل یا ٹینسر کو شامل کرنے سے پہلے ایسا ہونا ضروری ہے۔ اگر learning_phase static طور پر سیٹ کیا جاتا ہے، Keras کو صارف کے منتخب کردہ کسی بھی موڈ میں بند کر دیا جائے گا۔

1.4 کیراس نے وقت کے ساتھ بیچ نارملائزیشن کو کیسے نافذ کیا؟

Keras نے بیچ نارملائزیشن کے رویے کو کئی بار تبدیل کیا ہے لیکن سب سے حالیہ اہم اپ ڈیٹ Keras 2.1.3 میں ہوا ہے۔ v2.1.3 سے پہلے جب BN پرت کو منجمد کیا گیا تھا (trainable = False) وہ اپنے بیچ کے اعدادوشمار کو اپ ڈیٹ کرتا رہا، جو اس کے صارفین کے لیے مہاکاوی سر درد کا باعث بنا۔

یہ صرف ایک عجیب و غریب پالیسی نہیں تھی، یہ دراصل غلط تھی۔ تصور کریں کہ کنوولوشنز کے درمیان ایک BN پرت موجود ہے۔ اگر پرت منجمد ہو تو اس میں کوئی تبدیلی نہیں ہونی چاہیے۔ اگر ہم اس کے وزن کو جزوی طور پر اپ ڈیٹ کرتے ہیں اور اگلی پرتیں بھی منجمد کر دی جاتی ہیں، تو انہیں کبھی بھی منی بیچ کے اعدادوشمار کے اپ ڈیٹس کو ایڈجسٹ کرنے کا موقع نہیں ملے گا جس کی وجہ سے زیادہ خرابی ہو گی۔ شکر ہے کہ ورژن 2.1.3 سے شروع کرتے ہوئے، جب ایک BN پرت منجمد ہو جاتی ہے تو یہ اپنے اعدادوشمار کو اپ ڈیٹ نہیں کرتی ہے۔ لیکن کیا یہ کافی ہے؟ نہیں اگر آپ ٹرانسفر لرننگ استعمال کر رہے ہیں۔

ذیل میں میں بالکل واضح کرتا ہوں کہ مسئلہ کیا ہے اور میں اسے حل کرنے کے لیے تکنیکی عمل درآمد کا خاکہ بناتا ہوں۔ میں اس سے پہلے اور بعد میں ماڈل کی درستگی پر اثرات کو ظاہر کرنے کے لیے چند مثالیں بھی فراہم کرتا ہوں۔ پیچ لاگو کیا جاتا ہے.

2.1 مسئلے کی تکنیکی وضاحت

Keras کے موجودہ نفاذ کے ساتھ مسئلہ یہ ہے کہ جب ایک BN پرت منجمد ہو جاتی ہے، تو یہ تربیت کے دوران منی بیچ کے اعدادوشمار کا استعمال جاری رکھتی ہے۔ مجھے یقین ہے کہ جب BN کو منجمد کیا جاتا ہے تو ایک بہتر نقطہ نظر یہ ہے کہ وہ حرکت پذیر وسط اور تغیرات کو استعمال کرے جو اس نے تربیت کے دوران سیکھا۔ کیوں؟ انہی وجوہات کی بناء پر جب پرت منجمد ہو تو منی بیچ کے اعدادوشمار کو اپ ڈیٹ نہیں کیا جانا چاہئے: یہ خراب نتائج کا باعث بن سکتا ہے کیونکہ اگلی تہوں کو صحیح طریقے سے تربیت نہیں دی گئی ہے۔

فرض کریں کہ آپ ایک کمپیوٹر وژن ماڈل بنا رہے ہیں لیکن آپ کے پاس کافی ڈیٹا نہیں ہے، اس لیے آپ کیراس کے پہلے سے تربیت یافتہ CNNs میں سے ایک کو استعمال کرنے اور اسے ٹھیک کرنے کا فیصلہ کرتے ہیں۔ بدقسمتی سے، ایسا کرنے سے آپ کو اس بات کی کوئی گارنٹی نہیں ملتی ہے کہ BN تہوں کے اندر آپ کے نئے ڈیٹاسیٹ کا اوسط اور تغیر اصل ڈیٹاسیٹ کے جیسا ہی ہوگا۔ یاد رکھیں کہ اس وقت، تربیت کے دوران آپ کا نیٹ ورک ہمیشہ منی بیچ کے اعدادوشمار کا استعمال کرے گا یا تو BN پرت منجمد ہے یا نہیں؛ قیاس کے دوران بھی آپ منجمد BN تہوں کے پہلے سیکھے گئے اعدادوشمار استعمال کریں گے۔ نتیجے کے طور پر، اگر آپ اوپر کی تہوں کو ٹھیک کرتے ہیں، تو ان کے وزن کو اوسط/تغیر کے مطابق ایڈجسٹ کیا جائے گا۔ نیا ڈیٹاسیٹ بہر حال، قیاس کے دوران وہ ڈیٹا حاصل کریں گے جس کی پیمائش کی گئی ہے۔ مختلف کیونکہ کا مطلب/تغیر اصل ڈیٹا سیٹ استعمال کیا جائے گا۔

اوپر میں مظاہرے کے مقاصد کے لیے ایک سادہ (اور غیر حقیقی) فن تعمیر فراہم کرتا ہوں۔ آئیے فرض کریں کہ ہم ماڈل کو Convolution k+1 سے نیٹ ورک کے اوپر (دائیں طرف) تک ٹھیک کرتے ہیں اور ہم نیچے (بائیں طرف) کو منجمد کرتے رہتے ہیں۔ ٹریننگ کے دوران 1 سے k تک کی تمام BN پرتیں آپ کے ٹریننگ ڈیٹا کا اوسط/تغیر استعمال کریں گی۔ اس کے منجمد ReLUs پر منفی اثرات مرتب ہوں گے اگر ہر BN پر اوسط اور فرق پری ٹریننگ کے دوران سیکھے گئے لوگوں کے قریب نہ ہو۔ یہ بقیہ نیٹ ورک (CONV k+1 اور بعد میں سے) کو ان پٹ کے ساتھ تربیت دینے کا سبب بھی بنے گا جس کے مختلف پیمانے ہوتے ہیں اس کے مقابلے میں جو قیاس کے دوران حاصل ہوتا ہے۔ تربیت کے دوران آپ کا نیٹ ورک ان تبدیلیوں کو اپنا سکتا ہے، اس کے باوجود جس لمحے آپ پیشین گوئی کے موڈ پر جائیں گے، Keras مختلف معیاری اعدادوشمار استعمال کرے گا، جو کہ اگلی پرتوں کے ان پٹس کی تقسیم کو تیز کرے گا جس کے نتیجے میں خراب نتائج برآمد ہوں گے۔

2.2 اگر آپ متاثر ہوئے ہیں تو آپ کیسے پتہ لگا سکتے ہیں؟

اس کا پتہ لگانے کا ایک طریقہ یہ ہے کہ کیراس کے سیکھنے کے مرحلے کو 1 (ٹرین موڈ) اور 0 (ٹیسٹ موڈ) پر سیٹ کریں اور ہر معاملے میں اپنے ماڈل کا اندازہ کریں۔ اگر ایک ہی ڈیٹا سیٹ پر درستگی میں اہم فرق ہے، تو آپ اس مسئلے سے متاثر ہو رہے ہیں۔ یہ بتانے کے قابل ہے کہ، جس طرح سے لرننگ_فیز میکانزم کو Keras میں لاگو کیا جاتا ہے، عام طور پر اس کے ساتھ گڑبڑ کرنے کا مشورہ نہیں دیا جاتا ہے۔ Learning_phase میں تبدیلیوں کا ان ماڈلز پر کوئی اثر نہیں پڑے گا جو پہلے سے مرتب اور استعمال ہو چکے ہیں۔ جیسا کہ آپ اگلے ذیلی حصوں کی مثالوں میں دیکھ سکتے ہیں، ایسا کرنے کا بہترین طریقہ یہ ہے کہ ایک صاف سیشن کے ساتھ شروع کریں اور گراف میں کسی بھی ٹینسر کی وضاحت سے پہلے Learning_phase کو تبدیل کریں۔

بائنری درجہ بندی کے ساتھ کام کرتے ہوئے مسئلہ کا پتہ لگانے کا دوسرا طریقہ درستگی اور AUC کو چیک کرنا ہے۔ اگر درستگی 50% کے قریب ہے لیکن AUC 1 کے قریب ہے (اور آپ اسی ڈیٹاسیٹ پر ٹرین/ٹیسٹ موڈ کے درمیان فرق بھی دیکھتے ہیں)، تو یہ ہو سکتا ہے کہ BN کے اعدادوشمار کی وجہ سے امکانات حد سے زیادہ ہوں۔ اسی طرح، رجعت کے لیے آپ اس کا پتہ لگانے کے لیے MSE اور Spearman کے ارتباط کا استعمال کر سکتے ہیں۔

2.3 ہم اسے کیسے ٹھیک کر سکتے ہیں؟

مجھے یقین ہے کہ مسئلہ حل ہو سکتا ہے اگر منجمد BN پرتیں اصل میں صرف وہی ہیں: ٹیسٹ موڈ میں مستقل طور پر مقفل۔ نفاذ کے لحاظ سے، قابل تربیت پرچم کو کمپیوٹیشنل گراف کا حصہ بننے کی ضرورت ہے اور BN کے رویے کو نہ صرف سیکھنے کے_مرحلے پر بلکہ قابل تربیت جائیداد کی قدر پر بھی انحصار کرنے کی ضرورت ہے۔ آپ کو میرے نفاذ کی تفصیلات پر مل سکتی ہیں۔ Github کے.

مندرجہ بالا اصلاحات کو لاگو کرنے سے، جب ایک BN پرت منجمد ہو جائے گی تو یہ منی بیچ کے اعداد و شمار کو استعمال نہیں کرے گی بلکہ اس کے بجائے تربیت کے دوران سیکھے گئے اعداد و شمار کا استعمال کرے گی۔ نتیجے کے طور پر، تربیت اور ٹیسٹ کے طریقوں میں کوئی فرق نہیں ہوگا جس کی وجہ سے درستگی میں اضافہ ہوتا ہے۔ ظاہر ہے جب BN پرت منجمد نہیں ہوتی ہے، تو یہ تربیت کے دوران منی بیچ کے اعدادوشمار کا استعمال جاری رکھے گی۔

2.4 پیچ کے اثرات کا اندازہ لگانا

اگرچہ میں نے حال ہی میں مندرجہ بالا عمل کو لکھا ہے، اس کے پیچھے خیال کو حقیقی دنیا کے مسائل پر مختلف کاموں کا استعمال کرتے ہوئے بہت زیادہ تجربہ کیا گیا ہے جس کا ایک ہی اثر ہے۔ مثال کے طور پر، ٹریننگ اور ٹیسٹنگ طریقوں کے درمیان فرق اور نیٹ ورک کو دو حصوں (منجمد اور غیر منجمد) میں تقسیم کرکے اور کیشڈ ٹریننگ (ایک بار منجمد ماڈل کے ذریعے ڈیٹا پاس کرنا اور پھر ان کو غیر منجمد نیٹ ورک کو تربیت دینے کے لیے استعمال کرنا) سے بچا جا سکتا ہے۔ بہر حال، چونکہ "مجھ پر بھروسہ کریں میں نے یہ پہلے کیا ہے" عام طور پر کوئی وزن نہیں رکھتا، ذیل میں میں چند مثالیں فراہم کرتا ہوں جو عملی طور پر نئے نفاذ کے اثرات کو ظاہر کرتی ہیں۔

تجربے کے بارے میں چند اہم نکات یہ ہیں:

1. میں جان بوجھ کر ماڈل کو اوور فٹ کرنے کے لیے تھوڑا سا ڈیٹا استعمال کروں گا اور میں اسی ڈیٹاسیٹ پر ماڈل کی تربیت اور تصدیق کروں گا۔ ایسا کرنے سے، میں ٹرین/توثیق ڈیٹاسیٹ پر بالکل درستگی اور یکساں کارکردگی کی توقع کرتا ہوں۔
2. اگر توثیق کے دوران مجھے اسی ڈیٹاسیٹ پر نمایاں طور پر کم درستگی ملتی ہے، تو مجھے ایک واضح اشارہ ملے گا کہ موجودہ BN پالیسی تخمینہ کے دوران ماڈل کی کارکردگی کو منفی طور پر متاثر کرتی ہے۔
3. کوئی بھی پری پروسیسنگ جنریٹرز کے باہر ہو گی۔ یہ ایک بگ کے ارد گرد کام کرنے کے لئے کیا جاتا ہے جو v2.1.5 میں متعارف کرایا گیا تھا (فی الحال آنے والے v2.1.6 اور تازہ ترین ماسٹر پر طے کیا گیا ہے)۔
4. ہم کیراس کو تشخیص کے دوران سیکھنے کے مختلف مراحل استعمال کرنے پر مجبور کریں گے۔ اگر ہم رپورٹ کردہ درستگی کے درمیان فرق دیکھتے ہیں تو ہمیں معلوم ہو جائے گا کہ ہم موجودہ BN پالیسی سے متاثر ہیں۔

تجربے کا کوڈ ذیل میں دکھایا گیا ہے:

import numpy as np
from keras.datasets import cifar10
from scipy.misc import imresize

from keras.preprocessing.image import ImageDataGenerator
from keras.applications.resnet50 import ResNet50, preprocess_input
from keras.models import Model, load_model
from keras.layers import Dense, Flatten
from keras import backend as K


seed = 42
epochs = 10
records_per_class = 100

# We take only 2 classes from CIFAR10 and a very small sample to intentionally overfit the model.
# We will also use the same data for train/test and expect that Keras will give the same accuracy.
(x, y), _ = cifar10.load_data()

def filter_resize(category):
   # We do the preprocessing here instead in the Generator to get around a bug on Keras 2.1.5.
   return [preprocess_input(imresize(img, (224,224)).astype('float')) for img in x[y.flatten()==category][:records_per_class]]

x = np.stack(filter_resize(3)+filter_resize(5))
records_per_class = x.shape[0] // 2
y = np.array([[1,0]]*records_per_class + [[0,1]]*records_per_class)


# We will use a pre-trained model and finetune the top layers.
np.random.seed(seed)
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
l = Flatten()(base_model.output)
predictions = Dense(2, activation='softmax')(l)
model = Model(inputs=base_model.input, outputs=predictions)

for layer in model.layers[:140]:
   layer.trainable = False

for layer in model.layers[140:]:
   layer.trainable = True

model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit_generator(ImageDataGenerator().flow(x, y, seed=42), epochs=epochs, validation_data=ImageDataGenerator().flow(x, y, seed=42))

# Store the model on disk
model.save('tmp.h5')


# In every test we will clear the session and reload the model to force Learning_Phase values to change.
print('DYNAMIC LEARNING_PHASE')
K.clear_session()
model = load_model('tmp.h5')
# This accuracy should match exactly the one of the validation set on the last iteration.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))


print('STATIC LEARNING_PHASE = 0')
K.clear_session()
K.set_learning_phase(0)
model = load_model('tmp.h5')
# Again the accuracy should match the above.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))


print('STATIC LEARNING_PHASE = 1')
K.clear_session()
K.set_learning_phase(1)
model = load_model('tmp.h5')
# The accuracy will be close to the one of the training set on the last iteration.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))

آئیے Keras v2.1.5 پر نتائج چیک کریں:

Epoch 1/10
1/7 [===>..........................] - ETA: 25s - loss: 0.8751 - acc: 0.5312
2/7 [=======>......................] - ETA: 11s - loss: 0.8594 - acc: 0.4531
3/7 [===========>..................] - ETA: 7s - loss: 0.8398 - acc: 0.4688 
4/7 [================>.............] - ETA: 4s - loss: 0.8467 - acc: 0.4844
5/7 [====================>.........] - ETA: 2s - loss: 0.7904 - acc: 0.5437
6/7 [========================>.....] - ETA: 1s - loss: 0.7593 - acc: 0.5625
7/7 [==============================] - 12s 2s/step - loss: 0.7536 - acc: 0.5744 - val_loss: 0.6526 - val_acc: 0.6650

Epoch 2/10
1/7 [===>..........................] - ETA: 4s - loss: 0.3881 - acc: 0.8125
2/7 [=======>......................] - ETA: 3s - loss: 0.3945 - acc: 0.7812
3/7 [===========>..................] - ETA: 2s - loss: 0.3956 - acc: 0.8229
4/7 [================>.............] - ETA: 1s - loss: 0.4223 - acc: 0.8047
5/7 [====================>.........] - ETA: 1s - loss: 0.4483 - acc: 0.7812
6/7 [========================>.....] - ETA: 0s - loss: 0.4325 - acc: 0.7917
7/7 [==============================] - 8s 1s/step - loss: 0.4095 - acc: 0.8089 - val_loss: 0.4722 - val_acc: 0.7700

Epoch 3/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2246 - acc: 0.9375
2/7 [=======>......................] - ETA: 3s - loss: 0.2167 - acc: 0.9375
3/7 [===========>..................] - ETA: 2s - loss: 0.2260 - acc: 0.9479
4/7 [================>.............] - ETA: 2s - loss: 0.2179 - acc: 0.9375
5/7 [====================>.........] - ETA: 1s - loss: 0.2356 - acc: 0.9313
6/7 [========================>.....] - ETA: 0s - loss: 0.2392 - acc: 0.9427
7/7 [==============================] - 8s 1s/step - loss: 0.2288 - acc: 0.9456 - val_loss: 0.4282 - val_acc: 0.7800

Epoch 4/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2183 - acc: 0.9688
2/7 [=======>......................] - ETA: 3s - loss: 0.1899 - acc: 0.9844
3/7 [===========>..................] - ETA: 2s - loss: 0.1887 - acc: 0.9792
4/7 [================>.............] - ETA: 1s - loss: 0.1995 - acc: 0.9531
5/7 [====================>.........] - ETA: 1s - loss: 0.1932 - acc: 0.9625
6/7 [========================>.....] - ETA: 0s - loss: 0.1819 - acc: 0.9688
7/7 [==============================] - 8s 1s/step - loss: 0.1743 - acc: 0.9747 - val_loss: 0.3778 - val_acc: 0.8400

Epoch 5/10
1/7 [===>..........................] - ETA: 3s - loss: 0.0973 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0828 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0851 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0897 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0928 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0936 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.1337 - acc: 0.9838 - val_loss: 0.3916 - val_acc: 0.8100

Epoch 6/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0747 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0852 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0812 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0831 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0779 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0766 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.0813 - acc: 1.0000 - val_loss: 0.3637 - val_acc: 0.8550

Epoch 7/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2478 - acc: 0.8750
2/7 [=======>......................] - ETA: 2s - loss: 0.1966 - acc: 0.9375
3/7 [===========>..................] - ETA: 2s - loss: 0.1528 - acc: 0.9583
4/7 [================>.............] - ETA: 1s - loss: 0.1300 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.1193 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.1196 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.1084 - acc: 0.9838 - val_loss: 0.3546 - val_acc: 0.8600

Epoch 8/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0539 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0900 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0815 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0740 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0700 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0701 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.0695 - acc: 1.0000 - val_loss: 0.3269 - val_acc: 0.8600

Epoch 9/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0306 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0377 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0898 - acc: 0.9583
4/7 [================>.............] - ETA: 1s - loss: 0.0773 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.0742 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.0708 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.0659 - acc: 0.9838 - val_loss: 0.3604 - val_acc: 0.8600

Epoch 10/10
1/7 [===>..........................] - ETA: 3s - loss: 0.0354 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0381 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0354 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0828 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.0791 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.0794 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.0704 - acc: 0.9838 - val_loss: 0.3615 - val_acc: 0.8600

DYNAMIC LEARNING_PHASE
[0.3614931714534759, 0.86]

STATIC LEARNING_PHASE = 0
[0.3614931714534759, 0.86]

STATIC LEARNING_PHASE = 1
[0.025861846953630446, 1.0]

جیسا کہ ہم اوپر دیکھ سکتے ہیں، ٹریننگ کے دوران ماڈل ڈیٹا کو بہت اچھی طرح سے سیکھتا ہے اور ٹریننگ سیٹ پر بالکل درستگی حاصل کرتا ہے۔ اب بھی ہر تکرار کے اختتام پر، اسی ڈیٹاسیٹ پر ماڈل کا جائزہ لیتے ہوئے، ہمیں نقصان اور درستگی میں نمایاں فرق ملتا ہے۔ نوٹ کریں کہ ہمیں یہ نہیں ملنا چاہئے؛ ہم نے مخصوص ڈیٹاسیٹ پر ماڈل کو جان بوجھ کر اوور فٹ کیا ہے اور ٹریننگ/توثیق ڈیٹاسیٹ ایک جیسے ہیں۔

ٹریننگ مکمل ہونے کے بعد ہم 3 مختلف لرننگ_فیز کنفیگریشنز کا استعمال کرتے ہوئے ماڈل کا جائزہ لیتے ہیں: ڈائنامک، سٹیٹک = 0 (ٹیسٹ موڈ) اور سٹیٹک = 1 (ٹریننگ موڈ)۔ جیسا کہ ہم دیکھ سکتے ہیں کہ پہلی دو کنفیگریشنز نقصان اور درستگی کے لحاظ سے یکساں نتائج فراہم کریں گی اور ان کی قیمت آخری تکرار میں ترتیب دی گئی توثیق پر ماڈل کی رپورٹ کردہ درستگی سے ملتی ہے۔ اس کے باوجود، ایک بار جب ہم ٹریننگ موڈ پر چلے جاتے ہیں، تو ہم بڑے پیمانے پر فرق (بہتری) کا مشاہدہ کرتے ہیں۔ ایسا کیوں؟ جیسا کہ ہم نے پہلے کہا، نیٹ ورک کے وزن کو تربیتی ڈیٹا کے وسط/تغیر کے ساتھ چھوٹا ڈیٹا حاصل کرنے کی توقع کے مطابق بنایا گیا ہے۔ بدقسمتی سے، وہ اعداد و شمار BN تہوں میں محفوظ کردہ اعداد و شمار سے مختلف ہیں۔ چونکہ BN پرتیں منجمد تھیں، ان اعدادوشمار کو کبھی اپ ڈیٹ نہیں کیا گیا۔ BN کے اعدادوشمار کی اقدار کے درمیان یہ تفاوت قیاس کے دوران درستگی کے بگاڑ کا باعث بنتا ہے۔

آئیے دیکھتے ہیں کہ ایک بار لاگو کرنے کے بعد کیا ہوتا ہے۔ پیچ:

Epoch 1/10
1/7 [===>..........................] - ETA: 26s - loss: 0.9992 - acc: 0.4375
2/7 [=======>......................] - ETA: 12s - loss: 1.0534 - acc: 0.4375
3/7 [===========>..................] - ETA: 7s - loss: 1.0592 - acc: 0.4479 
4/7 [================>.............] - ETA: 4s - loss: 0.9618 - acc: 0.5000
5/7 [====================>.........] - ETA: 2s - loss: 0.8933 - acc: 0.5250
6/7 [========================>.....] - ETA: 1s - loss: 0.8638 - acc: 0.5417
7/7 [==============================] - 13s 2s/step - loss: 0.8357 - acc: 0.5570 - val_loss: 0.2414 - val_acc: 0.9450

Epoch 2/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2331 - acc: 0.9688
2/7 [=======>......................] - ETA: 2s - loss: 0.3308 - acc: 0.8594
3/7 [===========>..................] - ETA: 2s - loss: 0.3986 - acc: 0.8125
4/7 [================>.............] - ETA: 1s - loss: 0.3721 - acc: 0.8281
5/7 [====================>.........] - ETA: 1s - loss: 0.3449 - acc: 0.8438
6/7 [========================>.....] - ETA: 0s - loss: 0.3168 - acc: 0.8646
7/7 [==============================] - 9s 1s/step - loss: 0.3165 - acc: 0.8633 - val_loss: 0.1167 - val_acc: 0.9950

Epoch 3/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2457 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.2592 - acc: 0.9688
3/7 [===========>..................] - ETA: 2s - loss: 0.2173 - acc: 0.9688
4/7 [================>.............] - ETA: 1s - loss: 0.2122 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.2003 - acc: 0.9688
6/7 [========================>.....] - ETA: 0s - loss: 0.1896 - acc: 0.9740
7/7 [==============================] - 9s 1s/step - loss: 0.1835 - acc: 0.9773 - val_loss: 0.0678 - val_acc: 1.0000

Epoch 4/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2051 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.1652 - acc: 0.9844
3/7 [===========>..................] - ETA: 2s - loss: 0.1423 - acc: 0.9896
4/7 [================>.............] - ETA: 1s - loss: 0.1289 - acc: 0.9922
5/7 [====================>.........] - ETA: 1s - loss: 0.1225 - acc: 0.9938
6/7 [========================>.....] - ETA: 0s - loss: 0.1149 - acc: 0.9948
7/7 [==============================] - 9s 1s/step - loss: 0.1060 - acc: 0.9955 - val_loss: 0.0455 - val_acc: 1.0000

Epoch 5/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0769 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0846 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0797 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0736 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0914 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0858 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0808 - acc: 1.0000 - val_loss: 0.0346 - val_acc: 1.0000

Epoch 6/10
1/7 [===>..........................] - ETA: 1s - loss: 0.1267 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.1039 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0893 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0780 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0758 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0789 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0738 - acc: 1.0000 - val_loss: 0.0248 - val_acc: 1.0000

Epoch 7/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0344 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0385 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0467 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0445 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0446 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0429 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0421 - acc: 1.0000 - val_loss: 0.0202 - val_acc: 1.0000

Epoch 8/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0319 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0300 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0320 - acc: 1.0000
4/7 [================>.............] - ETA: 2s - loss: 0.0307 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0303 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0291 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0358 - acc: 1.0000 - val_loss: 0.0167 - val_acc: 1.0000

Epoch 9/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0246 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0255 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0258 - acc: 1.0000
4/7 [================>.............] - ETA: 2s - loss: 0.0250 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0252 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0260 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0327 - acc: 1.0000 - val_loss: 0.0143 - val_acc: 1.0000

Epoch 10/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0251 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0228 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0217 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0249 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0244 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0239 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0290 - acc: 1.0000 - val_loss: 0.0127 - val_acc: 1.0000

DYNAMIC LEARNING_PHASE
[0.012697912137955427, 1.0]

STATIC LEARNING_PHASE = 0
[0.012697912137955427, 1.0]

STATIC LEARNING_PHASE = 1
[0.01744014158844948, 1.0]

سب سے پہلے، ہم مشاہدہ کرتے ہیں کہ نیٹ ورک نمایاں طور پر تیزی سے تبدیل ہوتا ہے اور کامل درستگی حاصل کرتا ہے۔ ہم یہ بھی دیکھتے ہیں کہ جب ہم مختلف سیکھنے کے_مرحلے کی اقدار کے درمیان سوئچ کرتے ہیں تو درستگی کے لحاظ سے اب کوئی تضاد نہیں ہے۔

2.5 اصلی ڈیٹاسیٹ پر پیچ کس طرح پرفارم کرتا ہے؟

تو پیچ کس طرح زیادہ حقیقت پسندانہ تجربے پر کارکردگی کا مظاہرہ کرتا ہے؟ آئیے Keras کی پہلے سے تربیت یافتہ ResNet50 (اصل میں امیج نیٹ پر فٹ) استعمال کریں، اوپر کی درجہ بندی کی تہہ کو ہٹا دیں اور اسے پیچ کے ساتھ اور بغیر ٹھیک ٹیون کریں اور نتائج کا موازنہ کریں۔ ڈیٹا کے لیے، ہم CIFAR10 (کیراس کی طرف سے فراہم کردہ معیاری ٹرین/ٹیسٹ اسپلٹ) کا استعمال کریں گے اور ہم تصاویر کا سائز 224×224 کر دیں گے تاکہ انہیں ResNet50 کے ان پٹ سائز کے ساتھ ہم آہنگ بنایا جا سکے۔

ہم RSMprop کا استعمال کرتے ہوئے سب سے اوپر کی درجہ بندی کی پرت کو تربیت دینے کے لیے 10 دور کریں گے اور پھر SGD(lr=5e-139، momentum=1) کا استعمال کرتے ہوئے 4ویں پرت کے بعد سب کچھ ٹھیک کرنے کے لیے مزید 0.9 کریں گے۔ پیچ کے بغیر ہمارا ماڈل 87.44% کی درستگی حاصل کرتا ہے۔ پیچ کا استعمال کرتے ہوئے، ہمیں 92.36% کی درستگی ملتی ہے، تقریباً 5 پوائنٹ زیادہ۔

2.6 کیا ہمیں دوسری پرتوں جیسے ڈراپ آؤٹ پر بھی یہی فکس لگانا چاہیے؟

بیچ نارملائزیشن واحد پرت نہیں ہے جو ٹرین اور ٹیسٹ کے طریقوں کے درمیان مختلف طریقے سے کام کرتی ہے۔ ڈراپ آؤٹ اور اس کی مختلف حالتوں کا بھی یہی اثر ہے۔ کیا ہمیں ان تمام پرتوں پر ایک ہی پالیسی کا اطلاق کرنا چاہئے؟ مجھے یقین نہیں ہے (حالانکہ میں اس پر آپ کے خیالات سننا پسند کروں گا)۔ وجہ یہ ہے کہ ڈراپ آؤٹ کو اوور فٹنگ سے بچنے کے لیے استعمال کیا جاتا ہے، اس طرح اسے ٹریننگ کے دوران پیشن گوئی کے موڈ میں مستقل طور پر لاک کرنے سے اس کا مقصد ختم ہو جائے گا۔ آپ کیا سوچتے ہیں؟

میرا پختہ یقین ہے کہ کیراس میں اس تضاد کو حل کرنا ضروری ہے۔ میں نے اس مسئلے کی وجہ سے حقیقی دنیا کی ایپلی کیشنز میں اس سے بھی زیادہ گہرے اثرات (100% نیچے سے 50% درستگی تک) دیکھے ہیں۔ میں بھیجنے کا منصوبہ پہلے ہی ایک بھیجا ہے۔ PR کیراس کو فکس کے ساتھ اور امید ہے کہ اسے قبول کر لیا جائے گا۔

اگر آپ کو یہ بلاگ پوسٹ پسند ہے، تو براہ کرم اسے فیس بک یا ٹویٹر پر شیئر کرنے کے لیے تھوڑا وقت نکالیں۔ 🙂