ভূমিকা

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

আমি মৌলিক বোঝার জন্য এই নিবন্ধগুলি পড়ার সুপারিশ করব overfitting, underfitting এবং পক্ষপাত বৈষম্য ট্রেডঅফ।

উদ্দেশ্য শিখুন

• ওভারফিটিং এর কারণ, পরিণতি এবং পরিস্থিতি বুঝুন কনভনেট.
• নিউরাল নেটওয়ার্ক মডেলগুলিতে ওভারফিটিং এবং আন্ডারফিটিং সনাক্ত করতে শেখার কার্ভগুলি ব্যাখ্যা করুন।
• ওভারফিটিং প্রশমিত করার জন্য বিভিন্ন কৌশল শিখুন, যেমন তাড়াতাড়ি থামানো, ড্রপআউট, ব্যাচ স্বাভাবিককরণ, নিয়মিতকরণ এবং ডেটা বৃদ্ধি।
• এই কৌশলগুলি ব্যবহার করে প্রয়োগ করুন TensorFlow এবং কেরাস CIFAR-10 ডেটাসেটে কনভনেটকে প্রশিক্ষণ দেবে।
• মডেল কর্মক্ষমতা এবং সাধারণীকরণ উপর বিভিন্ন কৌশল প্রভাব বিশ্লেষণ.

ConvNet-এ ওভারফিটিংয়ের জন্য সাধারণ পরিস্থিতি

আসুন ConvNet-এ ওভারফিটিং-এর কিছু সাধারণ পরিস্থিতি বিবেচনা করি:

দৃশ্যকল্প1: অপর্যাপ্ত ডেটা সহ অত্যন্ত জটিল মডেল

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

ফল

মডেলটি প্রশিক্ষণের ডেটাতে খুব ভাল পারফর্ম করতে পারে কিন্তু নতুন, অদেখা ডেটাতে সাধারণীকরণ করতে ব্যর্থ হয়, যার ফলে বাস্তব-বিশ্বের অ্যাপ্লিকেশনগুলিতে খারাপ কার্যকারিতা দেখা দেয়।

কিভাবে এই সমস্যা সমাধান করতে?

আরও প্রশিক্ষণের ডেটা পান, আমাদের ডেটাসেটকে সাধারণীকরণ করতে ইমেজ অগমেন্টেশন করুন। কম জটিল মডেল দিয়ে শুরু করুন এবং ক্ষমতা কম হলে জটিলতা বাড়ান। 

দৃশ্যকল্প 2: অতিরিক্ত প্রশিক্ষণ

অনেক যুগের জন্য ক্রমাগত একটি মডেলকে প্রশিক্ষণ দিলে অতিরিক্ত ফিটিং হতে পারে। যেহেতু মডেলটি প্রশিক্ষণের ডেটা বারবার দেখে, এটি অন্তর্নিহিত নিদর্শনগুলি শেখার পরিবর্তে এটি মুখস্থ করা শুরু করতে পারে।

ফল

মডেলের কর্মক্ষমতা মালভূমি হতে পারে বা এমনকি অদেখা তথ্যের অবনতি হতে পারে কারণ এটি প্রশিক্ষণ সেটে ক্রমবর্ধমানভাবে বিশেষায়িত হয়ে ওঠে।

কিভাবে এই সমস্যা সমাধান করতে?

ওভারফিট করার জন্য মডেলটিকে এড়াতে এবং সেরা মডেলটিকে সংরক্ষণ করতে তাড়াতাড়ি স্টপিং ব্যবহার করুন। 

দৃশ্যকল্প3: নিয়মিতকরণ উপেক্ষা করা

নিয়মিতকরণের কৌশলগুলি, যেমন L1 বা L2 নিয়মিতকরণ, জটিল মডেলগুলিকে শাস্তি দেওয়ার মাধ্যমে অতিরিক্ত ফিটিং প্রতিরোধ করতে ব্যবহৃত হয়। নিয়মিতকরণের পরামিতিগুলিকে উপেক্ষা করা বা ভুলভাবে টিউন করা অতিরিক্ত ফিটিং হতে পারে।

ফল

মডেলটি অত্যধিক জটিল হয়ে উঠতে পারে এবং নতুন ডেটাতে ভালভাবে সাধারণীকরণ করতে ব্যর্থ হতে পারে, যার ফলে প্রশিক্ষণ সেটের বাইরে খারাপ কর্মক্ষমতা দেখা যায়।

কিভাবে এই সমস্যা সমাধান করতে?

নিয়মিতকরণ, ক্রস-ভ্যালিডেশন, হাইপার প্যারামিটার টিউনিং বাস্তবায়ন করুন। 

মডেল এর ক্ষমতা কি?

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

আপনি একটি নেটওয়ার্কের ক্ষমতা বাড়াতে পারেন এটিকে আরও প্রশস্ত করে (বিদ্যমান স্তরগুলিতে আরও ইউনিট) বা এটিকে আরও গভীর করে (আরও স্তর যুক্ত করে)। বৃহত্তর নেটওয়ার্কগুলিতে আরও রৈখিক সম্পর্ক শেখার সহজ সময় থাকে, যখন গভীর নেটওয়ার্কগুলি আরও অরৈখিক সম্পর্কগুলিকে পছন্দ করে। কোনটি ভাল তা কেবল ডেটাসেটের উপর নির্ভর করে।

শেখার বক্ররেখা ব্যাখ্যা

কেরাস প্রশিক্ষণের সময় কলব্যাক নিবন্ধন করার ক্ষমতা প্রদান করে গভীর শিক্ষার মডেল। সমস্ত গভীর শিক্ষার মডেল প্রশিক্ষণের সময় নিবন্ধিত ডিফল্ট কলব্যাকগুলির মধ্যে একটি হল ইতিহাস কলব্যাক৷ এটি প্রতিটি যুগের জন্য প্রশিক্ষণের মেট্রিক্স রেকর্ড করে। এর মধ্যে ক্ষতি এবং নির্ভুলতা (শ্রেণীবিন্যাস সমস্যার জন্য) এবং একটি সেট করা থাকলে বৈধতা ডেটাসেটের ক্ষতি এবং নির্ভুলতা অন্তর্ভুক্ত।

হিস্ট্রি অবজেক্টটি কল থেকে ফিট() ফাংশনে ফেরত দেওয়া হয় যা মডেলকে প্রশিক্ষণ দিতে ব্যবহৃত হয়। মেট্রিক্স ফিরে আসা বস্তুর ইতিহাস সদস্য একটি অভিধানে সংরক্ষণ করা হয়.

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

# list all data in history
print(history.history.keys())

আউটপুট:

['নির্ভুলতা', 'ক্ষতি', 'ভাল_নির্ভুলতা', 'ভাল_ক্ষয়']

তথ্য প্রকার

আপনি প্রশিক্ষণ ডেটার তথ্য দুটি ধরণের হিসাবে ভাবতে পারেন:

• সংকেত: সংকেত হল সেই অংশ যা সাধারণীকরণ করে, যে অংশটি আমাদের মডেলকে নতুন ডেটা থেকে ভবিষ্যদ্বাণী করতে সাহায্য করতে পারে৷
• নয়েজ: গোলমাল হল সেই অংশ যা শুধুমাত্র প্রশিক্ষণের তথ্যের ক্ষেত্রেই সত্য; গোলমাল হল সমস্ত এলোমেলো ওঠানামা যা বাস্তব জগতের ডেটা থেকে আসে বা সমস্ত আনুষঙ্গিক, অ-তথ্যমূলক নিদর্শন যা প্রকৃতপক্ষে মডেলটিকে ভবিষ্যদ্বাণী করতে সাহায্য করতে পারে না। গোলমাল হল অংশটি কার্যকরী মনে হতে পারে কিন্তু আসলে তা নয়।

যখন আমরা একটি মডেলকে প্রশিক্ষিত করি তখন আমরা যুগে যুগে প্রশিক্ষণ সেটের ক্ষতির পরিকল্পনা করি। এটিতে আমরা বৈধকরণ ডেটার একটি প্লটও যুক্ত করব। এই প্লটগুলোকে আমরা শেখার বক্ররেখা বলি। গভীর শিক্ষার মডেলগুলিকে কার্যকরভাবে প্রশিক্ষিত করার জন্য, আমাদের তাদের ব্যাখ্যা করতে সক্ষম হতে হবে।

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

ওভারফিটিং এড়ানোর পদ্ধতি

এখন যেহেতু আমরা কিছু পরিস্থিতি দেখেছি এবং কীভাবে ওভারফিটিং সনাক্ত করতে শেখার বক্ররেখা ব্যাখ্যা করতে হয়। আসুন নিউরাল নেটওয়ার্কে অতিরিক্ত ফিটিং এড়াতে কিছু পদ্ধতি চেকআউট করি:

পদ্ধতি 1: আরও ডেটা ব্যবহার করুন

আপনার ডেটাসেটের আকার বাড়ানো মডেলটিকে আরও ভালোভাবে সাধারণীকরণ করতে সাহায্য করতে পারে কারণ এটি থেকে শেখার জন্য আরও বিভিন্ন উদাহরণ রয়েছে৷ মডেলটি ডেটাসেটে উপস্থিত গুরুত্বপূর্ণ নিদর্শনগুলি খুঁজে পাবে এবং গোলমাল উপেক্ষা করবে কারণ মডেলটি বুঝতে পারে যে সেই নির্দিষ্ট প্যাটার্নগুলি (গোলমাল) সমস্ত ডেটাসেটে উপস্থিত নেই৷

পদ্ধতি 2: তাড়াতাড়ি থামানো

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

পদ্ধতি 3: ড্রপআউট

আমরা জানি যে ট্রেনিং ডেটাতে নেটওয়ার্ক শেখার জাল প্যাটার্ন (গোলমাল) এর কারণে ওভারফিটিং হয়। এই জাল প্যাটার্নগুলি চিনতে একটি নেটওয়ার্ক প্রায়শই ওজনের একটি নির্দিষ্ট সংমিশ্রণের উপর নির্ভর করে, ওজনের এক ধরণের "ষড়যন্ত্র"। এত সুনির্দিষ্ট হওয়ার কারণে, তারা ভঙ্গুর হতে থাকে: একটিকে সরান এবং ষড়যন্ত্রটি আলাদা হয়ে যায়।

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

আপনি ড্রপআউট সম্পর্কে এক ধরণের নেটওয়ার্ক তৈরি করার কথাও ভাবতে পারেন। ভবিষ্যদ্বাণীগুলি আর একটি বড় নেটওয়ার্ক দ্বারা করা হবে না, বরং ছোট নেটওয়ার্কগুলির একটি কমিটি দ্বারা করা হবে৷ কমিটিতে থাকা ব্যক্তিরা বিভিন্ন ধরণের ভুল করার প্রবণতা রাখে, কিন্তু একই সাথে সঠিক হতে পারে, কমিটিকে যেকোন ব্যক্তির চেয়ে সম্পূর্ণভাবে ভাল করে তোলে। (যদি আপনি সিদ্ধান্ত গাছের একটি অংশ হিসাবে এলোমেলো বনের সাথে পরিচিত হন তবে এটি একই ধারণা।)

পদ্ধতি 4: ব্যাচ স্বাভাবিককরণ

পরবর্তী বিশেষ পদ্ধতিটি আমরা দেখব "ব্যাচ নর্মালাইজেশন" (বা "ব্যাচনর্ম"), যা ধীর বা অস্থির প্রশিক্ষণকে সঠিক করতে সাহায্য করতে পারে।

নিউরাল নেটওয়ার্কগুলির সাথে, সাধারণত আপনার সমস্ত ডেটা একটি সাধারণ স্কেলে রাখা একটি ভাল ধারণা, সম্ভবত scikit-learn's StandardScaler বা MinMaxScaler এর মতো কিছু দিয়ে। কারণ হল যে SGD নেটওয়ার্ক ওজনগুলিকে সেই অনুপাতে স্থানান্তরিত করবে যে ডেটা কত বড় অ্যাক্টিভেশন তৈরি করে। যে বৈশিষ্ট্যগুলি খুব ভিন্ন আকারের অ্যাক্টিভেশন তৈরি করতে থাকে তা অস্থির প্রশিক্ষণের আচরণের জন্য তৈরি করতে পারে।

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

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

পদ্ধতি5: L1 এবং L2 নিয়মিতকরণ

L1 এবং L2 নিয়মিতকরণ হল নিউরাল নেটওয়ার্কে বৃহৎ ওজনকে শাস্তি দিয়ে ওভারফিটিং প্রতিরোধ করার জন্য ব্যবহৃত কৌশল। L1 নিয়মিতকরণ ওজনের পরম মানের সমানুপাতিক ক্ষতি ফাংশনে একটি পেনাল্টি শব্দ যোগ করে। এটি ওজনে স্প্যার্সিটি উত্সাহিত করে এবং বৈশিষ্ট্য নির্বাচনের দিকে নিয়ে যেতে পারে। L2 নিয়মিতকরণ, যা ওজন ক্ষয় নামেও পরিচিত, লস ফাংশনে ওজনের বর্গক্ষেত্রের সমানুপাতিক একটি শাস্তি শব্দ যোগ করে। এটি ওজনকে খুব বড় হতে বাধা দেয় এবং ওজনের বন্টনকে আরও সমানভাবে ছড়িয়ে দিতে উৎসাহিত করে।

L1 এবং L2 নিয়মিতকরণের মধ্যে পছন্দ প্রায়ই নির্দিষ্ট সমস্যা এবং মডেলের পছন্দসই বৈশিষ্ট্যের উপর নির্ভর করে।

L1/L2 নিয়মিতকরণের জন্য বড় মান থাকার কারণে মডেলটি দ্রুত শিখতে পারবে না এবং শেখার ক্ষেত্রে একটি মালভূমিতে পৌঁছাবে যার ফলে মডেলটি কম হবে। 

পদ্ধতি 6: ডেটা অগমেন্টেশন

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

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

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

মনে রাখবেন, ওভারফিটিং এড়ানোর চাবিকাঠি হল আপনার মডেলটি ভালভাবে সাধারণীকরণ করা নিশ্চিত করা। সবসময় আপনার মডেলের পারফরম্যান্স যাচাই করুন একটি বৈধতা সেটে, শুধু প্রশিক্ষণ সেট নয়।

ডেটা সহ উপরের পদ্ধতির বাস্তবায়ন

আসুন উপরের পদ্ধতিগুলির জন্য বাস্তবায়নের পদক্ষেপগুলি অন্বেষণ করি:

ধাপ 1: প্রয়োজনীয় লাইব্রেরি লোড করা হচ্ছে

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import ModelCheckpoint
import keras
from keras.preprocessing import image
from keras import models, layers, regularizers
from tqdm import tqdm
import warnings
warnings.filterwarnings(action='ignore')

ধাপ 2: ডেটাসেট লোড করা এবং প্রিপ্রসেসিং

#Here all the images are in the form of a numpy array
cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0

ধাপ 3: ডেটাসেট শেখা

x_train.shape, y_train.shape, x_test.shape, y_test.shape 

আউটপুট:

np.unique(y_train)

আউটপুট:

#These labels are in the order and taken from the documentaion
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

ধাপ 4: ডেটাসেট থেকে চিত্রটি ভিজ্যুয়ালাইজ করা

def show_image(IMG_INDEX):
    plt.imshow(x_train[20] ,cmap=plt.cm.binary)
    plt.xlabel(class_names[y_train[IMG_INDEX][0]])
    plt.show()
show_image(20)

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()

আসুন এখন অপ্টিমাইজার, লস ফাংশন এবং মূল্যায়ন মেট্রিক সহ হাইপার প্যারামিটার এবং কম্পাইলিং মডেল শুরু করি।

train_hyperparameters_config={'optim':keras.optimizers.Adam(learning_rate=0.001),
                             'epochs':20,
                              'batch_size':16
                             }
model.compile(optimizer=train_hyperparameters_config['optim'],
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])

ধাপ 6: প্রশিক্ষণ মডেল

history = model.fit(x_train, y_train, 
                        epochs=train_hyperparameters_config['epochs'], 
                        batch_size=train_hyperparameters_config['batch_size'], 
                        verbose=1,
                        validation_data=(x_test, y_test))

ধাপ 7: মডেলটি মূল্যায়ন করুন

এগুলি আমাদেরকে ইতিহাস অবজেক্টে থাকা তথ্য বলবে এবং আমরা আমাদের তথ্য বক্ররেখা তৈরি করতে সেগুলি ব্যবহার করি।

print(history.history.keys()) 

def learning_curves(history):
# Plotting Accuracy
    plt.figure(figsize=(14, 5))  # Adjust the figure size as needed
    plt.subplot(1, 2, 1)  # Subplot with 1 row, 2 columns, and index 1
    plt.plot(history.history['accuracy'], label='train_accuracy', marker='s', markersize=4)
    plt.plot(history.history['val_accuracy'], label='val_accuracy', marker='*', markersize=4)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend(loc='lower right')

    # Plotting Loss
    plt.subplot(1, 2, 2)  # Subplot with 1 row, 2 columns, and index 2
    plt.plot(history.history['loss'], label='train_loss', marker='s', markersize=4)
    plt.plot(history.history['val_loss'], label='val_loss', marker='*', markersize=4)
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend(loc='lower right')

    plt.show()
learning_curves(history)

বক্ররেখা থেকে আমরা দেখতে পাচ্ছি যে বৈধতা নির্ভুলতা 4 র্থ যুগের পরে একটি মালভূমিতে পৌঁছে এবং মডেলটি শব্দ ক্যাপচার করতে শুরু করে। তাই আমরা মডেলকে ওভারফিটিং এড়াতে এবং ভাল_লসের উপর ভিত্তি করে সেরা ওজন পুনরুদ্ধার করতে তাড়াতাড়ি স্টপিং প্রয়োগ করব। আমাদের নিউরাল নেটওয়ার্ক অপ্টিমাইজার ব্যবহার করে ক্ষতি কমানোর চেষ্টা করে বলে আমরা তাড়াতাড়ি স্টপিং নিরীক্ষণ করতে val_loss ব্যবহার করব। নির্ভুলতা এবং বৈধতা নির্ভুলতা থ্রেশহোল্ডের উপর নির্ভর করে (একটি ক্লাস আলাদা করার সম্ভাবনা - সাধারণত বাইনারি শ্রেণীবিভাগের জন্য 0.5), তাই যদি আমাদের ডেটাসেট ভারসাম্যহীন হয় তবে এটি ক্ষতির কারণ হবে আমাদের বেশিরভাগ ক্ষেত্রেই চিন্তা করা উচিত। 

ধাপ 8: প্রারম্ভিক স্টপিং বাস্তবায়ন

যেহেতু আমরা আমাদের মডেলকে ওভারফিট করার বিষয়ে চিন্তিত নই কারণ তাড়াতাড়ি বন্ধ করা আমাদের মডেলটিকে ঘটতে এড়াবে। উচ্চ সংখ্যক যুগ এবং একটি উপযুক্ত ধৈর্য বেছে নেওয়া একটি ভাল পছন্দ। এখন আমরা একই মডেলের আর্কিটেকচার ব্যবহার করব এবং তাড়াতাড়ি স্টপিং কলব্যাক সহ ট্রেন করব। 

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)

def model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config):
    model.compile(optimizer=train_hyperparameters_config['optim'],
                      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                      metrics=['accuracy'])
    ht = model.fit(x_train, y_train, 
                            epochs=train_hyperparameters_config['epochs'], 
                            batch_size=train_hyperparameters_config['batch_size'],
                            callbacks=[callback],
                            verbose=1,
                            validation_data=(x_test, y_test))
    return ht

ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

আমাদের সেরা ওজন জানতে যে মডেল নিয়েছে. 

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

ধাপ 9: মডেল জটিলতা বৃদ্ধি

যেহেতু আমাদের মডেলটি ভাল পারফর্ম করছে না এবং পর্যাপ্ত ডেটা ক্যাপচার করতে পারছে না তাই আন্ডারফিট। আমাদের মডেল জটিলতা বৃদ্ধি এবং মূল্যায়ন করা উচিত. 

model = models.Sequential()

model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.summary()

আমরা দেখতে পাচ্ছি মোট প্যারামিটার বৃদ্ধি পেয়েছে। এটি আমাদের মডেলে আরও জটিল সম্পর্ক খুঁজে পেতে সাহায্য করবে। দ্রষ্টব্য: আমাদের ডেটাসেট 32X32 চিত্রের; এগুলো তুলনামূলকভাবে ছোট ছবি। তাই শুরুতে আরও জটিল মডেল ব্যবহার করা অবশ্যই মডেলটিকে ওভারফিট করবে তাই আমরা ধীরে ধীরে আমাদের মডেল জটিলতা বাড়াতে থাকি।

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

উপরের গ্রাফগুলি থেকে আমরা স্পষ্টভাবে বলতে পারি যে মডেলটি ওভারফিটিং, তাই আমরা ড্রপ আউট নরমালাইজেশন এবং ব্যাচ নরমালাইজেশন নামে আরেকটি পদ্ধতি ব্যবহার করব।

ধাপ 10: ড্রপআউট লেয়ার এবং ব্যাচ নরমালাইজেশন লেয়ার ব্যবহার করা

model = models.Sequential()

model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))

model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))

model.add(layers.Dense(10, activation='softmax'))
model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

শেখার গ্রাফগুলি থেকে আমরা দেখতে পাচ্ছি যে মডেলটি এমনকি ব্যাচনরমালাইজেশন এবং ড্রপআউট স্তরগুলির সাথে ওভারফিটিং। তাই জটিলতা বাড়ানোর পরিবর্তে ফিল্টারের সংখ্যা বাড়ানো। আমরা আরো বৈশিষ্ট্য নিষ্কাশন করার জন্য আরো কনভলিউশন স্তর যোগ করব।

ধাপ 11: কনভোলিউশন লেয়ার বাড়ানো

প্রশিক্ষণযোগ্য পরামিতি হ্রাস করুন তবে আরও বৈশিষ্ট্যগুলি বের করতে কনভোলিউশন স্তরগুলি বাড়ান।

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))

model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 5,
    'epochs': 50,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

উপরের আউটপুট এবং শেখার বক্ররেখা থেকে আমরা অনুমান করতে পারি যে মডেলটি খুব ভাল পারফর্ম করেছে এবং অতিরিক্ত ফিটিং এড়িয়ে গেছে। প্রশিক্ষণ সঠিকতা এবং বৈধতা নির্ভুলতা খুব কাছাকাছি. এই পরিস্থিতিতে ওভারফিটিং কমাতে আমাদের আর কোনো পদ্ধতির প্রয়োজন হবে না। তবুও আমরা L1/L2 নিয়মিতকরণ অন্বেষণ করব। 

ধাপ 12: L1/L2 নিয়মিতকরণ ব্যবহার করা

from tensorflow.keras import regularizers

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l1(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu', kernel_regularizer=regularizers.l1_l2(0.0005, 0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 7,
    'epochs': 70,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

এখন আমরা দেখতে পাচ্ছি যে 1 এর কম পেনাল্টি স্কোর ব্যবহার করার পরেও L2/L0.0001 নিয়মিতকরণ, আমাদের মডেলকে 4% কম করেছে। তাই সাবধানতার সাথে সমস্ত পদ্ধতি একসাথে ব্যবহার করার পরামর্শ দেওয়া হচ্ছে। যেহেতু ব্যাচ স্বাভাবিককরণ এবং নিয়মিতকরণ একইভাবে মডেলকে প্রভাবিত করে আমাদের L1/L2 নিয়মিতকরণের প্রয়োজন হবে না। 

ধাপ 13: ডেটা অগমেন্টেশন

আমরা tensorflow keras থেকে ImageDataGenerator ব্যবহার করব।

# creates a data generator object that transforms images
datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')

# pick an image to transform
test_img = x_train[20]
img = image.img_to_array(test_img)  # convert image to numpy arry
img = img.reshape((1,) + img.shape)  # reshape image

i = 0

for batch in datagen.flow(img, save_prefix='test', save_format='jpeg'):  # this loops runs forever until we break, saving images to current directory with specified prefix
    plt.figure(i)
    plot = plt.imshow(image.img_to_array(batch[0]))
    i += 1
    if i > 4:  # show 4 images
        break

plt.show()

এগুলি হল চারটি বর্ধিত চিত্র এবং একটি আসল চিত্র।

# Create an instance of the ImageDataGenerator
datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest'
)

# Create an iterator for the data generator
data_generator = datagen.flow(x_train, y_train, batch_size=32)

# Create empty lists to store the augmented images and labels
augmented_images = []
augmented_labels = []

# Loop over the data generator and append the augmented data to the lists
num_batches = len(x_train) // 32
progress_bar = tqdm(total=num_batches, desc="Augmenting data", unit="batch")

for i in range(num_batches):
    batch_images, batch_labels = next(data_generator)
    augmented_images.append(batch_images)
    augmented_labels.append(batch_labels)
    progress_bar.update(1)

progress_bar.close()

# Convert the lists to NumPy arrays
augmented_images = np.concatenate(augmented_images, axis=0)
augmented_labels = np.concatenate(augmented_labels, axis=0)

# Combine the original and augmented data
x_train_augmented = np.concatenate((x_train, augmented_images), axis=0)
y_train_augmented = np.concatenate((y_train, augmented_labels), axis=0)

আমরা আমাদের পরিবর্ধনের অগ্রগতি জানতে tqdm লাইব্রেরি ব্যবহার করেছি।

x_train_augmented.shape, y_train_augmented.shape

এটি পরিবর্ধনের পরে আমাদের ডেটাসেট। এখন এই ডেটাসেটটি ব্যবহার করুন এবং আমাদের মডেলকে প্রশিক্ষণ দিন।

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))

model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))

model.add(layers.Dense(10, activation='softmax'))

model.summary()

# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
    'optim': keras.optimizers.Adam(learning_rate=0.001),
    'patience': 10,
    'epochs': 70,
    'batch_size': 32, 
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', 
    min_delta=0.001, # minimium amount of change to count as an improvement
    patience=train_hyperparameters_config['patience'], 
    restore_best_weights=True)

ht=model_train(model, x_train_augmented, y_train_augmented, x_test, y_test, train_hyperparameters_config)

learning_curves(ht)

print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test,  y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)

আমরা দেখতে পাচ্ছি মডেলটি আরও সাধারণীকৃত এবং ক্ষতি হ্রাস পেয়েছে। আমরা আরও ভাল বৈধতা নির্ভুলতা পেয়েছি। তাই ডেটা পরিবর্ধন আমাদের মডেল নির্ভুলতা বাড়িয়েছে। 

উপসংহার

ওভারফিটিং গভীর শিক্ষার একটি সাধারণ সমস্যা, বিশেষ করে কনভনেটের মতো জটিল নিউরাল নেটওয়ার্ক আর্কিটেকচারে। অনুশীলনকারীরা ConvNets-এ ওভারফিটিং প্রতিরোধ করতে পারে এর মূল কারণগুলি বোঝার মাধ্যমে এবং যেখানে এটি ঘটে সেগুলি সনাক্ত করে। প্রাথমিকভাবে থামানো, ড্রপআউট, ব্যাচ স্বাভাবিককরণ, নিয়মিতকরণ এবং ডেটা বৃদ্ধির মতো কৌশলগুলি এই সমস্যাটি কমাতে সাহায্য করতে পারে। CIFAR-10 ডেটাসেটে এই কৌশলগুলি প্রয়োগ করা মডেল সাধারণীকরণ এবং কর্মক্ষমতাতে উল্লেখযোগ্য উন্নতি দেখায়। এই কৌশলগুলি আয়ত্ত করা এবং তাদের নীতিগুলি বোঝার ফলে শক্তিশালী এবং নির্ভরযোগ্য নিউরাল নেটওয়ার্ক মডেল হতে পারে।

সচরাচর জিজ্ঞাস্য

• এসইও চালিত বিষয়বস্তু এবং পিআর বিতরণ। আজই পরিবর্ধিত পান।
• PlatoData.Network উল্লম্ব জেনারেটিভ Ai. নিজেকে ক্ষমতায়িত করুন। এখানে প্রবেশ করুন.
• প্লেটোএআইস্ট্রিম। Web3 ইন্টেলিজেন্স। জ্ঞান প্রসারিত. এখানে প্রবেশ করুন.
• প্লেটোইএসজি। কার্বন, ক্লিনটেক, শক্তি, পরিবেশ সৌর, বর্জ্য ব্যবস্থাপনা. এখানে প্রবেশ করুন.
• প্লেটো হেলথ। বায়োটেক এবং ক্লিনিক্যাল ট্রায়াল ইন্টেলিজেন্স। এখানে প্রবেশ করুন.
• উত্স: https://www.analyticsvidhya.com/blog/2024/04/understanding-overfitting-in-convnets/