এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

কেরাস এবং আধুনিক কনভনেট, টিপিইউতে

1. ওভারভিউ

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

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

আপনি কি শিখবেন

আপনার কাস্টম মডেলগুলি দ্রুত তৈরি করতে কেরাস এবং টেনসর প্রসেসিং ইউনিট (TPUs) ব্যবহার করতে।
প্রশিক্ষণের ডেটা দক্ষতার সাথে লোড করতে tf.data.Dataset API এবং TFRecord ফর্ম্যাট ব্যবহার করতে।
প্রতারণা করতে 😈, আপনার নিজের মডেল তৈরি করার পরিবর্তে ট্রান্সফার লার্নিং ব্যবহার করুন।
কেরাস ক্রমিক এবং কার্যকরী মডেল শৈলী ব্যবহার করতে।
সফটম্যাক্স লেয়ার এবং ক্রস-এনট্রপি লস সহ আপনার নিজস্ব কেরাস ক্লাসিফায়ার তৈরি করতে।
কনভোলিউশনাল লেয়ারগুলির একটি ভাল পছন্দের সাথে আপনার মডেলকে সূক্ষ্ম-সুর করতে।
মডিউল, গ্লোবাল এভারেজ পুলিং ইত্যাদির মত আধুনিক কনভনেট আর্কিটেকচার আইডিয়া অন্বেষণ করতে।
স্কুইজেনেট আর্কিটেকচার ব্যবহার করে একটি সহজ আধুনিক কনভনেট তৈরি করা।

প্রতিক্রিয়া

আপনি যদি এই কোড ল্যাবে কিছু ভুল দেখতে পান, দয়া করে আমাদের বলুন। গিটহাব সমস্যার মাধ্যমে প্রতিক্রিয়া প্রদান করা যেতে পারে [ প্রতিক্রিয়া লিঙ্ক ]।

2. Google Colaboratory দ্রুত শুরু

এই ল্যাবটি Google Collaboratory ব্যবহার করে এবং আপনার পক্ষ থেকে কোন সেটআপের প্রয়োজন নেই৷ আপনি এটি একটি Chromebook থেকে চালাতে পারেন। অনুগ্রহ করে নীচের ফাইলটি খুলুন এবং Colab নোটবুকের সাথে নিজেকে পরিচিত করতে সেলগুলি চালান।

Welcome to Colab.ipynb

একটি TPU ব্যাকএন্ড নির্বাচন করুন

Colab মেনুতে, রানটাইম > রানটাইম পরিবর্তন করুন এবং তারপরে TPU নির্বাচন করুন। এই কোড ল্যাবে আপনি একটি শক্তিশালী TPU (টেনসর প্রসেসিং ইউনিট) ব্যবহার করবেন যা হার্ডওয়্যার-ত্বরিত প্রশিক্ষণের জন্য সমর্থিত। রানটাইমের সাথে সংযোগটি প্রথম সম্পাদনে স্বয়ংক্রিয়ভাবে ঘটবে, অথবা আপনি উপরের-ডান কোণে "সংযোগ" বোতামটি ব্যবহার করতে পারেন।

নোটবুক এক্সিকিউশন

একটি কক্ষে ক্লিক করে এবং Shift-ENTER ব্যবহার করে এক সময়ে সেলগুলি চালান৷ আপনি রানটাইম > সমস্ত চালান দিয়ে পুরো নোটবুক চালাতে পারেন

বিষয়বস্তুর সারণী

সমস্ত নোটবুকের বিষয়বস্তুর একটি টেবিল আছে। আপনি বাম দিকে কালো তীর ব্যবহার করে এটি খুলতে পারেন।

লুকানো কোষ

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

প্রমাণীকরণ

Colab-এর পক্ষে আপনার ব্যক্তিগত Google ক্লাউড স্টোরেজ বালতি অ্যাক্সেস করা সম্ভব যদি আপনি একটি অনুমোদিত অ্যাকাউন্টের মাধ্যমে প্রমাণীকরণ করেন। উপরের কোড স্নিপেট একটি প্রমাণীকরণ প্রক্রিয়া ট্রিগার করবে।

3. [তথ্য] টেনসর প্রসেসিং ইউনিট (TPUs) কি?

সংক্ষেপে

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

কেরাসে টিপিইউতে একটি মডেলকে প্রশিক্ষণের জন্য কোড (এবং একটি টিপিইউ উপলব্ধ না হলে GPU বা CPU-তে ফিরে আসে):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

ইন্টারেক্টিভ গতিতে (প্রশিক্ষণ প্রতি মিনিটে) একটি ফ্লাওয়ার ক্লাসিফায়ার তৈরি এবং অপ্টিমাইজ করতে আমরা আজ TPU ব্যবহার করব।

কেন টিপিইউ?

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

দৃষ্টান্ত: ম্যাট্রিক্স গুণিতক হিসাবে একটি ঘন নিউরাল নেটওয়ার্ক স্তর, একযোগে নিউরাল নেটওয়ার্কের মাধ্যমে প্রক্রিয়াকৃত আটটি চিত্রের ব্যাচ সহ। এটি একটি চিত্রের সমস্ত পিক্সেল মানের একটি ওজনযুক্ত যোগফল করছে কিনা তা যাচাই করতে অনুগ্রহ করে একটি লাইন x কলাম গুণনের মাধ্যমে চালান৷ কনভোল্যুশনাল লেয়ারগুলিকেও ম্যাট্রিক্স গুণন হিসাবে উপস্থাপন করা যেতে পারে যদিও এটি একটু বেশি জটিল ( এখানে ব্যাখ্যা, বিভাগ 1 এ )।

হার্ডওয়্যার

MXU এবং VPU

একটি TPU v2 কোর একটি ম্যাট্রিক্স মাল্টিপ্লাই ইউনিট (MXU) দিয়ে তৈরি যা ম্যাট্রিক্স গুণন চালায় এবং একটি ভেক্টর প্রসেসিং ইউনিট (VPU) অন্যান্য সমস্ত কাজ যেমন অ্যাক্টিভেশন, সফটম্যাক্স ইত্যাদির জন্য। VPU float32 এবং int32 গণনা পরিচালনা করে। অন্যদিকে MXU একটি মিশ্র নির্ভুলতা 16-32 বিট ফ্লোটিং পয়েন্ট ফর্ম্যাটে কাজ করে।

মিশ্র স্পষ্টতা ভাসমান বিন্দু এবং bfloat16

MXU bfloat16 ইনপুট এবং float32 আউটপুট ব্যবহার করে ম্যাট্রিক্স গুন গণনা করে। মধ্যবর্তী সঞ্চয়গুলি float32 নির্ভুলতায় সঞ্চালিত হয়।

নিউরাল নেটওয়ার্ক প্রশিক্ষণ সাধারণত কম ফ্লোটিং পয়েন্ট নির্ভুলতা দ্বারা প্রবর্তিত গোলমাল প্রতিরোধী। এমন কিছু ক্ষেত্রে আছে যেখানে শব্দ এমনকি অপ্টিমাইজারকে একত্রিত হতে সাহায্য করে। 16-বিট ফ্লোটিং পয়েন্ট নির্ভুলতা ঐতিহ্যগতভাবে গণনাকে ত্বরান্বিত করার জন্য ব্যবহার করা হয়েছে কিন্তু float16 এবং float32 বিন্যাসের খুব ভিন্ন রেঞ্জ রয়েছে। float32 থেকে float16-এ নির্ভুলতা হ্রাস করার ফলে সাধারণত ওভার এবং আন্ডারফ্লো হয়। সমাধান বিদ্যমান কিন্তু অতিরিক্ত কাজ সাধারণত float16 কাজ করতে প্রয়োজন হয়.

এই কারণেই গুগল টিপিইউতে bfloat16 ফর্ম্যাট চালু করেছে। bfloat16 হল একটি ছেঁটে যাওয়া float32 যার ফ্লোট32-এর মতো একই সূচক বিট এবং রেঞ্জ রয়েছে। এটির সাথে যোগ করা হয়েছে যে TPUs bfloat16 ইনপুট কিন্তু float32 আউটপুটগুলির সাথে মিশ্র নির্ভুলতায় ম্যাট্রিক্স গুণের গণনা করে, এর অর্থ হল, কম নির্ভুলতার কর্মক্ষমতা লাভ থেকে উপকৃত হওয়ার জন্য সাধারণত কোন কোড পরিবর্তনের প্রয়োজন হয় না।

সিস্টোলিক অ্যারে

MXU একটি তথাকথিত "সিস্টোলিক অ্যারে" আর্কিটেকচার ব্যবহার করে হার্ডওয়্যারে ম্যাট্রিক্স গুণন প্রয়োগ করে যেখানে ডেটা উপাদানগুলি হার্ডওয়্যার গণনা ইউনিটগুলির একটি অ্যারের মাধ্যমে প্রবাহিত হয়। (চিকিৎসায়, "সিস্টোলিক" বলতে হৃদপিন্ডের সংকোচন এবং রক্ত প্রবাহ বোঝায়, এখানে ডেটা প্রবাহকে বোঝায়।)

একটি ম্যাট্রিক্স গুণের মৌলিক উপাদান হল একটি ম্যাট্রিক্স থেকে একটি লাইন এবং অন্য ম্যাট্রিক্স থেকে একটি কলামের মধ্যে একটি বিন্দু গুণমান (এই বিভাগের শীর্ষে চিত্রটি দেখুন)। একটি ম্যাট্রিক্স গুণের জন্য Y=X*W, ফলাফলের একটি উপাদান হবে:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

একটি GPU-তে, কেউ এই ডট প্রোডাক্টটিকে একটি GPU "কোর"-এ প্রোগ্রাম করবে এবং তারপর একই সাথে ফলাফল ম্যাট্রিক্সের প্রতিটি মান গণনা করার জন্য সমান্তরালভাবে উপলব্ধ যতগুলি "কোর"-এ এটি কার্যকর করবে। ফলস্বরূপ ম্যাট্রিক্স 128x128 বড় হলে, এর জন্য 128x128=16K "কোর" উপলব্ধ হতে হবে যা সাধারণত সম্ভব নয়। বৃহত্তম জিপিইউতে প্রায় 4000 কোর রয়েছে। অন্যদিকে একটি TPU MXU-তে কম্পিউট ইউনিটের জন্য ন্যূনতম হার্ডওয়্যার ব্যবহার করে: শুধু bfloat16 x bfloat16 => float32 মাল্টিপ্লাই-অ্যাকুমুলেটর, অন্য কিছু নয়। এগুলি এতই ছোট যে একটি TPU একটি 128x128 MXU তে 16K প্রয়োগ করতে পারে এবং এই ম্যাট্রিক্স গুণকে একবারে প্রক্রিয়া করতে পারে।

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

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

মেঘ TPU

যখন আপনি Google ক্লাউড প্ল্যাটফর্মে একটি " ক্লাউড TPU v2" এর জন্য অনুরোধ করেন, আপনি একটি ভার্চুয়াল মেশিন (VM) পান যাতে একটি PCI-সংযুক্ত TPU বোর্ড থাকে৷ TPU বোর্ডে চারটি ডুয়াল-কোর TPU চিপ রয়েছে। প্রতিটি টিপিইউ কোরে একটি ভিপিইউ (ভেক্টর প্রসেসিং ইউনিট) এবং একটি 128x128 MXU (ম্যাট্রিক্স মাল্টিপ্লাই ইউনিট) বৈশিষ্ট্যযুক্ত। এই "ক্লাউড টিপিইউ" সাধারণত নেটওয়ার্কের মাধ্যমে ভিএমের সাথে সংযুক্ত থাকে যা এটির অনুরোধ করেছিল৷ তাই সম্পূর্ণ ছবি এই মত দেখায়:

উদাহরণ: নেটওয়ার্ক-সংযুক্ত "ক্লাউড টিপিইউ" অ্যাক্সিলারেটরের সাথে আপনার ভিএম। "দ্য ক্লাউড টিপিইউ" নিজেই একটি পিসিআই-সংযুক্ত টিপিইউ বোর্ড সহ একটি ভিএম দিয়ে তৈরি যার উপরে চারটি ডুয়াল-কোর টিপিইউ চিপ রয়েছে৷

TPU শুঁটি

Google-এর ডেটা সেন্টারগুলিতে, TPU গুলি একটি উচ্চ-পারফরম্যান্স কম্পিউটিং (HPC) আন্তঃসংযোগের সাথে সংযুক্ত থাকে যা তাদের একটি খুব বড় অ্যাক্সিলারেটর হিসাবে দেখাতে পারে। গুগল তাদের পড বলে এবং তারা 512 টিপিইউ ভি2 কোর বা 2048 টিপিইউ ভি3 কোর পর্যন্ত অন্তর্ভুক্ত করতে পারে।

উদাহরণ: একটি TPU v3 পড। TPU বোর্ড এবং র্যাকগুলি HPC আন্তঃসংযোগের মাধ্যমে সংযুক্ত।

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

উদাহরণ: Google TPU-এর 2-D টরয়েডাল মেশ HPC নেটওয়ার্কে অল-রিডুস অ্যালগরিদম ব্যবহার করে প্রশিক্ষণের সময় গ্রেডিয়েন্টের সিঙ্ক্রোনাইজেশন।

সফটওয়্যার

বড় ব্যাচ আকারের প্রশিক্ষণ

TPU-গুলির জন্য আদর্শ ব্যাচের আকার হল প্রতি TPU কোরে 128টি ডেটা আইটেম কিন্তু হার্ডওয়্যারটি ইতিমধ্যেই প্রতি TPU কোরে 8টি ডেটা আইটেম থেকে ভাল ব্যবহার দেখাতে পারে। মনে রাখবেন যে একটি ক্লাউড টিপিইউতে 8টি কোর রয়েছে।

এই কোড ল্যাবে, আমরা Keras API ব্যবহার করব। কেরাসে, আপনি যে ব্যাচটি নির্দিষ্ট করেছেন তা হল সমগ্র TPU-এর জন্য বিশ্বব্যাপী ব্যাচের আকার। আপনার ব্যাচগুলি স্বয়ংক্রিয়ভাবে 8-এ বিভক্ত হবে এবং TPU-এর 8টি কোরে চলবে।

অতিরিক্ত পারফরম্যান্স টিপসের জন্য TPU পারফরম্যান্স গাইড দেখুন। খুব বড় ব্যাচের আকারের জন্য, কিছু মডেলে বিশেষ যত্নের প্রয়োজন হতে পারে, আরও বিস্তারিত জানার জন্য LARSOptimizer দেখুন।

হুড অধীনে: XLA

টেনসরফ্লো প্রোগ্রাম গণনা গ্রাফ সংজ্ঞায়িত করে। TPU সরাসরি পাইথন কোড চালায় না, এটি আপনার টেনসরফ্লো প্রোগ্রাম দ্বারা সংজ্ঞায়িত গণনা গ্রাফ চালায়। হুডের নিচে, XLA (এক্সিলারেটেড লিনিয়ার অ্যালজেব্রা কম্পাইলার) নামক একটি কম্পাইলার কম্পিউটেশন নোডের টেনসরফ্লো গ্রাফকে TPU মেশিন কোডে রূপান্তরিত করে। এই কম্পাইলারটি আপনার কোড এবং আপনার মেমরি লেআউটে অনেক উন্নত অপ্টিমাইজেশন সঞ্চালন করে। TPU-তে কাজ পাঠানোর সাথে সাথে সংকলন স্বয়ংক্রিয়ভাবে ঘটে। আপনাকে স্পষ্টভাবে আপনার বিল্ড চেইনে XLA অন্তর্ভুক্ত করতে হবে না।

উদাহরণ: TPU-তে চালানোর জন্য, আপনার Tensorflow প্রোগ্রাম দ্বারা সংজ্ঞায়িত গণনা গ্রাফটি প্রথমে একটি XLA (ত্বরিত লিনিয়ার অ্যালজেব্রা কম্পাইলার) উপস্থাপনায় অনুবাদ করা হয়, তারপর XLA দ্বারা TPU মেশিন কোডে সংকলিত হয়।

কেরাসে টিপিইউ ব্যবহার করা

TPUs কেরাস API এর মাধ্যমে Tensorflow 2.1 এর মাধ্যমে সমর্থিত। কেরাস সমর্থন টিপিইউ এবং টিপিইউ পডগুলিতে কাজ করে। এখানে একটি উদাহরণ রয়েছে যা TPU, GPU(গুলি) এবং CPU-তে কাজ করে:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

এই কোড স্নিপেটে:

TPUClusterResolver().connect() নেটওয়ার্কে TPU খুঁজে পায়। এটি বেশিরভাগ Google ক্লাউড সিস্টেমে (AI Platform jobs, Colaboratory, Kubeflow, 'ctpu up' ইউটিলিটির মাধ্যমে তৈরি ডিপ লার্নিং ভিএম) প্যারামিটার ছাড়াই কাজ করে। TPU_NAME এনভায়রনমেন্ট ভেরিয়েবলের জন্য এই সিস্টেমগুলি জানে যে তাদের TPU কোথায় আছে৷ আপনি যদি হাতে একটি TPU তৈরি করেন, হয় TPU_NAME env সেট করুন৷ var আপনি যে VM থেকে এটি ব্যবহার করছেন তাতে, অথবা স্পষ্ট প্যারামিটার সহ TPUClusterResolver কল করুন: TPUClusterResolver(tp_uname, zone, project)
TPUStrategy হল সেই অংশ যা ডিস্ট্রিবিউশন এবং "অল-রিডুস" গ্রেডিয়েন্ট সিঙ্ক্রোনাইজেশন অ্যালগরিদম প্রয়োগ করে।
কৌশল একটি সুযোগ মাধ্যমে প্রয়োগ করা হয়. মডেলটিকে অবশ্যই কৌশলের সুযোগ() এর মধ্যে সংজ্ঞায়িত করতে হবে।
tpu_model.fit ফাংশন টিপিইউ প্রশিক্ষণের জন্য ইনপুটের জন্য একটি tf.data.Dataset অবজেক্ট আশা করে।

সাধারণ TPU পোর্টিং কাজ

টেনসরফ্লো মডেলে ডেটা লোড করার অনেক উপায় থাকলেও, TPU-এর জন্য, tf.data.Dataset API ব্যবহার করা প্রয়োজন।
টিপিইউগুলি খুব দ্রুত এবং সেগুলি চালানোর সময় ডেটা গ্রহণ করা প্রায়শই বাধা হয়ে দাঁড়ায়৷ টিপিইউ পারফরম্যান্স গাইডে ডেটা বাধা এবং অন্যান্য কর্মক্ষমতা টিপস সনাক্ত করতে আপনি এমন সরঞ্জামগুলি ব্যবহার করতে পারেন।
int8 বা int16 সংখ্যাগুলিকে int32 হিসাবে গণ্য করা হয়। TPU-তে 32 বিটের কম পূর্ণসংখ্যার হার্ডওয়্যার অপারেটিং নেই।
কিছু Tensorflow অপারেশন সমর্থিত নয়। তালিকা এখানে আছে . ভাল খবর হল এই সীমাবদ্ধতা শুধুমাত্র ট্রেনিং কোডের ক্ষেত্রে প্রযোজ্য, অর্থাৎ আপনার মডেলের মধ্য দিয়ে ফরওয়ার্ড এবং পিছন দিকে পাস। আপনি এখনও আপনার ডেটা ইনপুট পাইপলাইনে সমস্ত Tensorflow অপারেশন ব্যবহার করতে পারেন কারণ এটি CPU-তে কার্যকর করা হবে।
tf.py_func TPU তে সমর্থিত নয়।

4. ডেটা লোড হচ্ছে

আমরা ফুলের ছবির একটি ডেটাসেট নিয়ে কাজ করব। লক্ষ্য হল তাদের 5 টি ফুলের প্রকারে শ্রেণীবদ্ধ করা শিখতে হবে। tf.data.Dataset API ব্যবহার করে ডেটা লোড করা হয়। প্রথমে, আসুন এপিআই সম্পর্কে জানতে পারি।

হাতে-কলমে

অনুগ্রহ করে নিচের নোটবুকটি খুলুন, সেলগুলি চালান (Shift-ENTER) এবং নির্দেশাবলী অনুসরণ করুন যেখানেই আপনি একটি "ওয়ার্ক রিকোয়ারড" লেবেল দেখতে পান৷

Fun with tf.data.Dataset (playground).ipynb

অতিরিক্ত তথ্য

"ফুল" ডেটাসেট সম্পর্কে

ডেটাসেটটি 5টি ফোল্ডারে সংগঠিত। প্রতিটি ফোল্ডারে এক ধরণের ফুল রয়েছে। ফোল্ডারগুলির নাম দেওয়া হয়েছে সূর্যমুখী, ডেইজি, ড্যান্ডেলিয়ন, টিউলিপস এবং গোলাপ। ডেটা Google ক্লাউড স্টোরেজে একটি পাবলিক বালতিতে হোস্ট করা হয়। উদ্ধৃতি:

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

কেন tf.data.Dataset?

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

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

আপনি এই নিবন্ধে পারফরম্যান্স টিপস এবং ডেটাসেটের সেরা অনুশীলনগুলি খুঁজে পেতে পারেন৷ রেফারেন্স ডকুমেন্টেশন এখানে আছে.

tf.data.Dataset বেসিক

ডেটা সাধারণত একাধিক ফাইলে আসে, এখানে ইমেজ। আপনি কল করে ফাইলের নামের একটি ডেটাসেট তৈরি করতে পারেন:

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

তারপরে আপনি প্রতিটি ফাইলের নামের সাথে একটি ফাংশন "ম্যাপ" করেন যা সাধারণত মেমরিতে প্রকৃত ডেটাতে ফাইলটিকে লোড এবং ডিকোড করবে:

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

একটি ডেটাসেটে পুনরাবৃত্তি করতে:

for data in my_dataset:
  print(data)

টিপলের ডেটাসেট

তত্ত্বাবধানে শেখার ক্ষেত্রে, একটি প্রশিক্ষণ ডেটাসেট সাধারণত জোড়া প্রশিক্ষণ ডেটা এবং সঠিক উত্তর দিয়ে তৈরি হয়। এটির অনুমতি দেওয়ার জন্য, ডিকোডিং ফাংশন টিপল ফেরত দিতে পারে। তারপরে আপনার কাছে টিপলের একটি ডেটাসেট থাকবে এবং আপনি এটিতে পুনরাবৃত্তি করলে টিপলগুলি ফেরত দেওয়া হবে। প্রত্যাবর্তিত মানগুলি হল টেনসরফ্লো টেনসরগুলি আপনার মডেলের দ্বারা খাওয়ার জন্য প্রস্তুত৷ কাঁচা মান দেখতে আপনি .numpy() কল করতে পারেন:

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

উপসংহার: একের পর এক ছবি লোড করা ধীর!

আপনি এই ডেটাসেটে পুনরাবৃত্তি করার সাথে সাথে আপনি দেখতে পাবেন যে আপনি প্রতি সেকেন্ডে 1-2টি ছবি লোড করতে পারেন। যে খুব ধীর! আমরা প্রশিক্ষণের জন্য যে হার্ডওয়্যার এক্সিলারেটরগুলি ব্যবহার করব তা এই হার অনেক গুণ ধরে রাখতে পারে। আমরা কীভাবে এটি অর্জন করব তা দেখতে পরবর্তী বিভাগে যান।

সমাধান

এখানে সমাধান নোটবুক. আপনি আটকে থাকলে আপনি এটি ব্যবহার করতে পারেন।

Fun with tf.data.Dataset (solution).ipynb

আমরা কভার করেছি কি

🤔 tf.data.Dataset.list_files
🤔 tf.data.Dataset.map
🤔 টিপলের ডেটাসেট
😀 ডেটাসেটের মাধ্যমে পুনরাবৃত্তি করা হচ্ছে

আপনার মাথায় এই চেকলিস্টের মধ্য দিয়ে যাওয়ার জন্য অনুগ্রহ করে একটু সময় নিন।

5. দ্রুত ডেটা লোড হচ্ছে

এই ল্যাবে আমরা যে টেনসর প্রসেসিং ইউনিট (TPU) হার্ডওয়্যার এক্সিলারেটর ব্যবহার করব তা খুব দ্রুত। তাদের ব্যস্ত রাখার জন্য তাদের যথেষ্ট দ্রুত ডেটা খাওয়ানো প্রায়ই চ্যালেঞ্জ। Google ক্লাউড স্টোরেজ (GCS) খুব উচ্চ থ্রুপুট বজায় রাখতে সক্ষম কিন্তু সমস্ত ক্লাউড স্টোরেজ সিস্টেমের মতো, একটি সংযোগ শুরু করতে কিছু নেটওয়ার্কের পিছনে পিছনে খরচ হয়। অতএব, হাজার হাজার পৃথক ফাইল হিসাবে আমাদের ডেটা সংরক্ষণ করা আদর্শ নয়। আমরা সেগুলিকে অল্প সংখ্যক ফাইলে ব্যাচ করতে যাচ্ছি এবং সমান্তরালভাবে একাধিক ফাইল থেকে পড়ার জন্য tf.data.Dataset এর শক্তি ব্যবহার করব।

রিড-থ্রু

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

Flower pictures to TFRecords.ipynb

সর্বোত্তম GCS থ্রুপুটের জন্য আদর্শ ডেটা লেআউট

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

TFRecord ফাইল বিন্যাস

ডেটা সংরক্ষণের জন্য Tensorflow-এর পছন্দের ফাইল ফরম্যাট হল প্রোটোবাফ -ভিত্তিক TFRecord ফরম্যাট। অন্যান্য সিরিয়ালাইজেশন ফর্ম্যাটগুলিও কাজ করবে তবে আপনি সরাসরি লিখে TFRecord ফাইলগুলি থেকে একটি ডেটাসেট লোড করতে পারেন:

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

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

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

TFRrecord চিট শীট

TFRecords এ তিন ধরনের ডেটা সংরক্ষণ করা যেতে পারে: বাইট স্ট্রিং (বাইটের তালিকা), 64 বিট পূর্ণসংখ্যা এবং 32 বিট ফ্লোট । এগুলি সর্বদা তালিকা হিসাবে সংরক্ষণ করা হয়, একটি একক ডেটা উপাদান 1 আকারের একটি তালিকা হবে। আপনি TFRecords এ ডেটা সংরক্ষণ করতে নিম্নলিখিত সহায়ক ফাংশনগুলি ব্যবহার করতে পারেন।

বাইট স্ট্রিং লেখা

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

পূর্ণসংখ্যা লেখা

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

লেখা ভাসা

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

উপরে সাহায্যকারী ব্যবহার করে একটি TFRecord লেখা

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

TFRecords থেকে ডেটা পড়তে, আপনাকে প্রথমে আপনার সংরক্ষণ করা রেকর্ডগুলির বিন্যাস ঘোষণা করতে হবে। ঘোষণায়, আপনি একটি নির্দিষ্ট দৈর্ঘ্যের তালিকা বা একটি পরিবর্তনশীল দৈর্ঘ্যের তালিকা হিসাবে যে কোনও নামযুক্ত ক্ষেত্র অ্যাক্সেস করতে পারেন:

TFRecords থেকে পড়া

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

দরকারী কোড স্নিপেট:

একক ডেটা উপাদান পড়া

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

উপাদানগুলির নির্দিষ্ট আকারের তালিকা পড়া

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

ডেটা আইটেম একটি পরিবর্তনশীল সংখ্যা পড়া

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

একটি VarLenFeature একটি স্পার্স ভেক্টর প্রদান করে এবং TFRecord ডিকোড করার পরে একটি অতিরিক্ত পদক্ষেপ প্রয়োজন:

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

TFRecords এ ঐচ্ছিক ক্ষেত্র থাকাও সম্ভব। যদি আপনি একটি ক্ষেত্র পড়ার সময় একটি ডিফল্ট মান নির্দিষ্ট করেন, তাহলে ক্ষেত্রটি অনুপস্থিত থাকলে একটি ত্রুটির পরিবর্তে ডিফল্ট মানটি ফেরত দেওয়া হয়।

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

আমরা কভার করেছি কি

🤔 জিসিএস থেকে দ্রুত অ্যাক্সেসের জন্য ডেটা ফাইলগুলিকে ভাগ করা
😓 কিভাবে TFRecords লিখতে হয়। (আপনি ইতিমধ্যে সিনট্যাক্স ভুলে গেছেন? ঠিক আছে, এই পৃষ্ঠাটিকে একটি চিট শীট হিসাবে বুকমার্ক করুন)
🤔 TFRecordDataset ব্যবহার করে TFRecords থেকে একটি ডেটাসেট লোড করা হচ্ছে

6. [তথ্য] নিউরাল নেটওয়ার্ক ক্লাসিফায়ার 101

সংক্ষেপে

যদি পরবর্তী অনুচ্ছেদে গাঢ় সব পদ আপনার কাছে ইতিমধ্যেই পরিচিত হয়, তাহলে আপনি পরবর্তী অনুশীলনে যেতে পারেন। আপনি যদি সবেমাত্র গভীর শিক্ষা শুরু করেন তাহলে স্বাগতম, এবং অনুগ্রহ করে পড়ুন।

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

স্তরগুলির একটি ক্রম হিসাবে নির্মিত মডেলগুলির জন্য কেরাস অনুক্রমিক API অফার করে। উদাহরণস্বরূপ, তিনটি ঘন স্তর ব্যবহার করে একটি ইমেজ ক্লাসিফায়ার কেরাসে এভাবে লেখা যেতে পারে:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

ঘন নিউরাল নেটওয়ার্ক

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

আপনি একটি ছবিকে এই জাতীয় নেটওয়ার্কে ফিড করতে পারেন এর সমস্ত পিক্সেলের RGB মানগুলিকে একটি লম্বা ভেক্টরে সমতল করে এবং এটিকে ইনপুট হিসাবে ব্যবহার করে৷ এটি ইমেজ শনাক্তকরণের জন্য সর্বোত্তম কৌশল নয় তবে আমরা পরে এটিতে উন্নতি করব।

নিউরন, অ্যাক্টিভেশন, RELU

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

সবচেয়ে জনপ্রিয় অ্যাক্টিভেশন ফাংশনটিকে রেক্টিফায়েড লিনিয়ার ইউনিটের জন্য RELU বলা হয়। এটি একটি খুব সাধারণ ফাংশন যা আপনি উপরের গ্রাফে দেখতে পাচ্ছেন।

সফটম্যাক্স অ্যাক্টিভেশন

উপরের নেটওয়ার্কটি একটি 5-নিউরন স্তর দিয়ে শেষ হয় কারণ আমরা ফুলকে 5টি বিভাগে শ্রেণীবদ্ধ করছি (গোলাপ, টিউলিপ, ড্যান্ডেলিয়ন, ডেইজি, সূর্যমুখী)। মধ্যবর্তী স্তরের নিউরনগুলি ক্লাসিক RELU অ্যাক্টিভেশন ফাংশন ব্যবহার করে সক্রিয় করা হয়। যদিও শেষ স্তরে, আমরা 0 এবং 1 এর মধ্যে সংখ্যা গণনা করতে চাই যা এই ফুলটি গোলাপ, একটি টিউলিপ ইত্যাদি হওয়ার সম্ভাবনার প্রতিনিধিত্ব করে। এর জন্য, আমরা "softmax" নামে একটি অ্যাক্টিভেশন ফাংশন ব্যবহার করব।

একটি ভেক্টরে সফটম্যাক্স প্রয়োগ করা হয় প্রতিটি উপাদানের সূচক নিয়ে এবং তারপর ভেক্টরটিকে স্বাভাবিক করার মাধ্যমে, সাধারণত L1 আদর্শ (পরম মানের সমষ্টি) ব্যবহার করে যাতে মানগুলি 1 পর্যন্ত যোগ হয় এবং সম্ভাব্যতা হিসাবে ব্যাখ্যা করা যায়।

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

ক্রস-এনট্রপি ক্ষতি

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

যেকোনো দূরত্ব কাজ করবে, কিন্তু শ্রেণীবিভাগের সমস্যার জন্য তথাকথিত "ক্রস-এনট্রপি দূরত্ব" সবচেয়ে কার্যকর । আমরা এটিকে আমাদের ত্রুটি বা "ক্ষতি" ফাংশন বলব:

" এক-হট " এনকোডিং এর অর্থ হল আপনি 5 মানের একটি ভেক্টর ব্যবহার করে "3) ড্যানডেলিয়ন লেবেলটি উপস্থাপন করেন, 3য় মানটি ব্যতীত সমস্ত শূন্য যা 1। এই ভেক্টরটি ড্যান্ডেলিয়ন হওয়ার 100% সম্ভাবনার প্রতিনিধিত্ব করে। আমাদের নিউরাল নেটওয়ার্ক 5টি সম্ভাব্যতা মানের ভেক্টর হিসাবে তার ভবিষ্যদ্বাণীগুলিকে আউটপুট করে। তারা তুলনা করা সহজ.

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

নিউরাল নেটওয়ার্কের "প্রশিক্ষণ" আসলে বোঝায় ওজন এবং পক্ষপাতগুলি সামঞ্জস্য করার জন্য প্রশিক্ষণের চিত্র এবং লেবেল ব্যবহার করা যাতে ক্রস-এনট্রপি লস ফাংশন কম করা যায়। এটি কিভাবে কাজ করে তা এখানে।

ক্রস-এনট্রপি হল ওজন, পক্ষপাত, প্রশিক্ষণ চিত্রের পিক্সেল এবং এর পরিচিত শ্রেণির একটি ফাংশন।

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

গ্রেডিয়েন্ট ডিসেন্ট2.png

" শেখার হার ": আপনি প্রতিটি পুনরাবৃত্তিতে গ্রেডিয়েন্টের পুরো দৈর্ঘ্য দ্বারা আপনার ওজন এবং পক্ষপাতগুলি আপডেট করতে পারবেন না। এটা হবে সেভেন লিগের বুট পরে উপত্যকার গভীরে যাওয়ার চেষ্টা করার মতো। আপনি উপত্যকার একপাশ থেকে অন্য দিকে ঝাঁপিয়ে পড়বেন। নীচে যাওয়ার জন্য, আপনাকে ছোট ধাপগুলি করতে হবে, যেমন গ্রেডিয়েন্টের শুধুমাত্র একটি ভগ্নাংশ ব্যবহার করুন, সাধারণত 1/1000তম পরিসরে। এই ভগ্নাংশটিকে "শিক্ষার হার" বলা হয়।

মিনি-ব্যাচিং এবং ভরবেগ

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

এই কৌশলটি, যাকে কখনও কখনও "স্টোকাস্টিক গ্রেডিয়েন্ট ডিসেন্ট" বলা হয়, এর আরও একটি, আরও বাস্তবসম্মত সুবিধা রয়েছে: ব্যাচগুলির সাথে কাজ করার অর্থ আরও বড় ম্যাট্রিক্সের সাথে কাজ করা এবং এগুলি সাধারণত GPU এবং TPU-তে অপ্টিমাইজ করা সহজ।

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

উদাহরণ: একটি স্যাডল পয়েন্ট। গ্রেডিয়েন্ট 0 কিন্তু এটি সব দিক থেকে ন্যূনতম নয়। (ইমেজ অ্যাট্রিবিউশন উইকিমিডিয়া: নিকোগুয়ারো দ্বারা - নিজের কাজ, CC BY 3.0 )

সমাধান হল অপ্টিমাইজেশান অ্যালগরিদমে কিছু গতিবেগ যোগ করা যাতে এটি থেমে না গিয়ে অতীতের স্যাডল পয়েন্টে যেতে পারে।

শব্দকোষ

ব্যাচ বা মিনি-ব্যাচ : প্রশিক্ষণ সর্বদা প্রশিক্ষণ ডেটা এবং লেবেলের ব্যাচে সঞ্চালিত হয়। এটি করা অ্যালগরিদমকে একত্রিত করতে সহায়তা করে। "ব্যাচ" মাত্রা সাধারণত ডেটা টেনসরের প্রথম মাত্রা। উদাহরণস্বরূপ আকৃতির একটি টেনসর [100, 192, 192, 3] প্রতি পিক্সেল (RGB) তিনটি মান সহ 192x192 পিক্সেলের 100টি চিত্র রয়েছে।

ক্রস-এনট্রপি লস : একটি বিশেষ ক্ষতি ফাংশন যা প্রায়ই ক্লাসিফায়ারে ব্যবহৃত হয়।

ঘন স্তর : নিউরনের একটি স্তর যেখানে প্রতিটি নিউরন পূর্ববর্তী স্তরের সমস্ত নিউরনের সাথে সংযুক্ত থাকে।

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

লেবেল : তত্ত্বাবধানে শ্রেণীবিভাগের সমস্যায় "ক্লাস" বা সঠিক উত্তরের অন্য নাম

শেখার হার : গ্রেডিয়েন্টের ভগ্নাংশ যার দ্বারা প্রশিক্ষণ লুপের প্রতিটি পুনরাবৃত্তিতে ওজন এবং পক্ষপাতগুলি আপডেট করা হয়।

logits : অ্যাক্টিভেশন ফাংশন প্রয়োগ করার আগে নিউরনের একটি স্তরের আউটপুটকে "লগিট" বলা হয়। শব্দটি "লজিস্টিক ফাংশন" ওরফে "সিগময়েড ফাংশন" থেকে এসেছে যা সবচেয়ে জনপ্রিয় অ্যাক্টিভেশন ফাংশন হিসাবে ব্যবহৃত হত। "লজিস্টিক ফাংশনের আগে নিউরন আউটপুট" কে সংক্ষিপ্ত করে "লজিট" করা হয়েছিল।

ক্ষতি : সঠিক উত্তরের সাথে নিউরাল নেটওয়ার্ক আউটপুট তুলনা করার ত্রুটি ফাংশন

নিউরন : এর ইনপুটগুলির ওজনযুক্ত যোগফল গণনা করে, একটি পক্ষপাত যোগ করে এবং একটি সক্রিয়করণ ফাংশনের মাধ্যমে ফলাফলকে ফিড করে।

ওয়ান-হট এনকোডিং : 5 এর মধ্যে 3 ক্লাস 5টি উপাদানের ভেক্টর হিসাবে এনকোড করা হয়েছে, 3য়টি ব্যতীত সমস্ত শূন্য যা 1।

relu : সংশোধনকৃত লিনিয়ার ইউনিট। নিউরনের জন্য একটি জনপ্রিয় অ্যাক্টিভেশন ফাংশন।

সিগমায়েড : আরেকটি অ্যাক্টিভেশন ফাংশন যা জনপ্রিয় ছিল এবং এখনও বিশেষ ক্ষেত্রে কার্যকর।

সফটম্যাক্স : একটি বিশেষ অ্যাক্টিভেশন ফাংশন যা একটি ভেক্টরের উপর কাজ করে, বৃহত্তম উপাদান এবং অন্য সকলের মধ্যে পার্থক্য বাড়ায় এবং ভেক্টরটিকে 1 এর সমষ্টিতে স্বাভাবিক করে তোলে যাতে এটি সম্ভাব্যতার ভেক্টর হিসাবে ব্যাখ্যা করা যায়। ক্লাসিফায়ারে শেষ ধাপ হিসেবে ব্যবহৃত হয়।

tensor : একটি "টেনসর" একটি ম্যাট্রিক্সের মত কিন্তু মাত্রার একটি ইচ্ছামত সংখ্যা সহ। একটি 1-মাত্রিক টেনসর একটি ভেক্টর। একটি 2-মাত্রা টেনসর একটি ম্যাট্রিক্স। এবং তারপরে আপনার 3, 4, 5 বা তার বেশি মাত্রা সহ টেনসর থাকতে পারে।

7. ট্রান্সফার লার্নিং

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

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

হাতে-কলমে

Keras Flowers transfer learning (playground).ipynb

অতিরিক্ত তথ্য

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

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

কেরাসে শিক্ষা স্থানান্তর করুন

কেরাসে, আপনি tf.keras.applications.* সংগ্রহ থেকে একটি প্রাক-প্রশিক্ষিত মডেল তৈরি করতে পারেন। উদাহরণস্বরূপ MobileNet V2 একটি খুব ভাল কনভোল্যুশনাল আর্কিটেকচার যা আকারে যুক্তিসঙ্গত থাকে। include_top=False নির্বাচন করে, আপনি তার চূড়ান্ত সফটম্যাক্স স্তর ছাড়াই প্রাক-প্রশিক্ষিত মডেল পাবেন যাতে আপনি নিজের যোগ করতে পারেন:

pretrained_model = tf.keras.applications.MobileNetV2(input_shape=[*IMAGE_SIZE, 3], include_top=False)
pretrained_model.trainable = False

model = tf.keras.Sequential([
    pretrained_model,
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(5, activation='softmax')
])

এছাড়াও pretrained_model.trainable = False সেটিং লক্ষ্য করুন। এটি প্রাক-প্রশিক্ষিত মডেলের ওজন এবং পক্ষপাতগুলিকে হিমায়িত করে যাতে আপনি শুধুমাত্র আপনার সফটম্যাক্স স্তরকে প্রশিক্ষণ দেন। এটি সাধারণত তুলনামূলকভাবে কম ওজন জড়িত থাকে এবং এটি দ্রুত এবং খুব বড় ডেটাসেটের প্রয়োজন ছাড়াই করা যেতে পারে। তবে যদি আপনার কাছে প্রচুর ডেটা থাকে, তাহলে ট্রান্সফার লার্নিং pretrained_model.trainable = True এর সাথে আরও ভাল কাজ করতে পারে। প্রাক-প্রশিক্ষিত ওজনগুলি তারপরে চমৎকার প্রাথমিক মান প্রদান করে এবং আপনার সমস্যাকে আরও ভালভাবে মানানসই করার জন্য প্রশিক্ষণের মাধ্যমে সামঞ্জস্য করা যেতে পারে।

অবশেষে, আপনার ঘন সফটম্যাক্স স্তরের আগে Flatten() স্তরটি ঢোকানো লক্ষ্য করুন। ঘন স্তরগুলি ডেটার ফ্ল্যাট ভেক্টরগুলিতে কাজ করে তবে আমরা জানি না যে এটি পূর্বপ্রশিক্ষিত মডেলটি ফেরত দেয় কিনা। সেজন্য আমাদের সমতল করা দরকার। পরের অধ্যায়ে, আমরা রূপান্তরমূলক স্থাপত্যগুলিতে ডুব দেওয়ার সময়, আমরা রূপান্তরমূলক স্তরগুলির দ্বারা ফিরে আসা ডেটা বিন্যাসটি ব্যাখ্যা করব।

এই পদ্ধতির সাথে আপনার 75% নির্ভুলতা পাওয়া উচিত।

সমাধান

এখানে সমাধান নোটবুক. আপনি আটকে থাকলে আপনি এটি ব্যবহার করতে পারেন।

Keras Flowers transfer learning (solution).ipynb

আমরা কভার করেছি কি

🤔 কিভাবে কেরাসে একটি শ্রেণীবিভাগ লিখবেন
🤓 একটি সফটম্যাক্স লাস্ট লেয়ার এবং ক্রস-এনট্রপি লস দিয়ে কনফিগার করা হয়েছে
😈 ট্রান্সফার লার্নিং
🤔 আপনার প্রথম মডেল প্রশিক্ষণ
🧐 প্রশিক্ষণের সময় এর ক্ষতি এবং নির্ভুলতা অনুসরণ করা

8. [তথ্য] কনভোল্যুশনাল নিউরাল নেটওয়ার্ক

সংক্ষেপে

যদি পরবর্তী অনুচ্ছেদে গাঢ় সব পদ আপনার কাছে ইতিমধ্যেই পরিচিত হয়, তাহলে আপনি পরবর্তী অনুশীলনে যেতে পারেন। যদি আপনার সবেমাত্র কনভোলিউশনাল নিউরাল নেটওয়ার্কগুলি দিয়ে শুরু হয় তবে দয়া করে পড়ুন।

কনভোলিউশনাল.জিফ

চিত্র: 4x4x3 = 48 প্রতিটি শিখতে পারে এমন দুটি ক্রমাগত ফিল্টার সহ একটি চিত্র ফিল্টার করা।

কনভোলিউশনাল নিউরাল নেটওয়ার্কগুলি ইনপুট চিত্রটিতে শিখতে পারা ফিল্টারগুলির একটি সিরিজ প্রয়োগ করে। একটি কনভোলিউশনাল স্তর ফিল্টার (বা কার্নেল) আকার , প্রয়োগ করা ফিল্টারগুলির সংখ্যা এবং স্ট্রাইড দ্বারা সংজ্ঞায়িত করা হয়। ইনপুট চিত্র (প্রস্থ, উচ্চতা, আরজিবি চ্যানেল) দিয়ে শুরু করে একটি কনভোলিউশনাল স্তরটির ইনপুট এবং আউটপুটটিতে তিনটি মাত্রা (প্রস্থ, উচ্চতা, চ্যানেলগুলির সংখ্যা) থাকে। কনভোলিউশনাল স্তরগুলি স্ট্যাক করার সময়, আউটপুটটির প্রস্থ এবং উচ্চতা একটি স্ট্রাইড> 1 ব্যবহার করে বা সর্বোচ্চ-পুলিং অপারেশন দিয়ে সামঞ্জস্য করা যায়। আউটপুটটির গভীরতা (চ্যানেলগুলির এনবি) আরও বা কম ফিল্টার ব্যবহার করে সামঞ্জস্য করা হয়।

এভাবেই একটি সাধারণ কনভোলিউশনাল নিউরাল নেটওয়ার্ক কেরাসে দেখায়:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

কনভোলিউশনাল নিউরাল নেট 101

একটি কনভোলিউশনাল নেটওয়ার্কের একটি স্তরে, একটি "নিউরন" কেবল চিত্রের একটি ছোট অঞ্চল জুড়ে এর উপরে পিক্সেলের একটি ওজনযুক্ত যোগফল করে। এটি একটি পক্ষপাত যুক্ত করে এবং একটি অ্যাক্টিভেশন ফাংশনের মাধ্যমে যোগফলকে ফিড দেয়, ঠিক যেমন নিয়মিত ঘন স্তরের নিউরন হয়। এই অপারেশনটি একই ওজন ব্যবহার করে পুরো চিত্র জুড়ে পুনরাবৃত্তি হয়। মনে রাখবেন যে ঘন স্তরগুলিতে, প্রতিটি নিউরনের নিজস্ব ওজন ছিল। এখানে, ওজনের একটি একক "প্যাচ" উভয় দিকের চিত্র জুড়ে স্লাইড করে (একটি "কনভোলিউশন")। চিত্রটিতে পিক্সেল যতটা আউটপুট রয়েছে তত বেশি মান রয়েছে (যদিও প্রান্তগুলিতে কিছু প্যাডিং প্রয়োজনীয়)। এটি 4x4x3 = 48 ওজনের ফিল্টার ব্যবহার করে একটি ফিল্টারিং অপারেশন।

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

স্ক্রিন শট 2016-07-29 এ 16.02.37.png এ

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

চিত্রণ: একটি কনভোলিউশনাল নিউরাল নেটওয়ার্ক ডেটা "কিউবসকে" ডেটা অন্যান্য "কিউবস" তে রূপান্তর করে।

স্ট্রাইড কনভোলিউশনস, সর্বাধিক পুলিং

2 বা 3 এর স্ট্রাইড সহ কনভোলিউশনগুলি সম্পাদন করে আমরা ফলাফলের ডেটা কিউবটিকে তার অনুভূমিক মাত্রায় সঙ্কুচিত করতে পারি। এটি করার দুটি সাধারণ উপায় রয়েছে:

স্ট্রাইড কনভোলিউশন: উপরের মতো একটি স্লাইডিং ফিল্টার তবে একটি স্ট্রাইড> 1
সর্বাধিক পুলিং: সর্বাধিক অপারেশন প্রয়োগ করে একটি স্লাইডিং উইন্ডো (সাধারণত 2x2 প্যাচগুলিতে, প্রতি 2 পিক্সেল পুনরাবৃত্তি করে)

চিত্র: 3 পিক্সেল দ্বারা কম্পিউটিং উইন্ডোটি স্লাইডিং করে ফলাফল কম আউটপুট মানগুলিতে। স্ট্রাইড কনভোলিউশনস বা সর্বাধিক পুলিং (2x2 উইন্ডোতে সর্বোচ্চ 2 এর স্ট্রাইড দ্বারা স্লাইডিং) অনুভূমিক মাত্রাগুলিতে ডেটা কিউব সঙ্কুচিত করার একটি উপায়।

" ম্যাক্স-পুলিং " আমাদের কীভাবে কনভোলিউশনাল নেটওয়ার্কগুলি পরিচালনা করে তা স্বজ্ঞাতভাবে বুঝতে সহায়তা করতে পারে: যদি আপনি ধরে নেন যে প্রশিক্ষণের সময়, ওজনের প্যাচগুলি ফিল্টারগুলিতে বিকশিত হয় যা মৌলিক আকারগুলি সনাক্ত করে (অনুভূমিক এবং উল্লম্ব লাইন, বক্ররেখা, ...) তারপরে ফুটন্ত একটি উপায় দরকারী তথ্য হ'ল স্তরগুলির মাধ্যমে আউটপুটগুলি রাখা যেখানে একটি আকার সর্বাধিক তীব্রতার সাথে স্বীকৃত ছিল। অনুশীলনে, একটি সর্বোচ্চ-পুল স্তরে নিউরনের আউটপুটগুলি 2x2 এর গ্রুপে প্রক্রিয়াজাত করা হয় এবং কেবলমাত্র সর্বোচ্চ মান ধরে রাখা হয়।

সি ওভলিউশনাল শ্রেণিবদ্ধকারী

অবশেষে, আমরা শেষ ডেটা কিউবকে সমতল করে এবং একটি ঘন, সফটম্যাক্স-সক্রিয় স্তরের মাধ্যমে খাওয়ানোর মাধ্যমে একটি শ্রেণিবিন্যাসের মাথা সংযুক্ত করি। একটি সাধারণ কনভোলিউশনাল শ্রেণিবদ্ধকারী এর মতো দেখতে পারে:

চিত্র: কনভোলিউশনাল এবং সফটম্যাক্স স্তরগুলি ব্যবহার করে একটি চিত্র শ্রেণিবদ্ধকারী। এটি 3x3 এবং 1x1 ফিল্টার ব্যবহার করে। ম্যাক্সপুল স্তরগুলি 2x2 ডেটা পয়েন্টের সর্বাধিক গ্রুপ নেয়। শ্রেণিবিন্যাসের মাথাটি সফটম্যাক্স অ্যাক্টিভেশন সহ একটি ঘন স্তর দিয়ে প্রয়োগ করা হয়।

কেরাসে

উপরে বর্ণিত কনভোলিউশনাল স্ট্যাকটি কেরাতে লিখিত হতে পারে:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

9. আপনার কাস্টম কনভনেট

হাতে-কলমে

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

Keras_Flowers_TPU (playground).ipynb

লক্ষ্যটি হ'ল ট্রান্সফার লার্নিং মডেলের 75% নির্ভুলতাকে পরাজিত করা। এই মডেলটির একটি সুবিধা ছিল, কয়েক মিলিয়ন চিত্রের ডেটাসেটে প্রাক প্রশিক্ষিত ছিল যখন আমাদের এখানে কেবল 3670 চিত্র রয়েছে। আপনি কি কমপক্ষে এটি মেলে?

অতিরিক্ত তথ্য

কত স্তর, কত বড়?

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

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

কয়েকটি টিপস:

একাধিক স্তর থাকা হ'ল "গভীর" নিউরাল নেটওয়ার্কগুলিকে কার্যকর করে তোলে। এই সাধারণ ফুলের স্বীকৃতি সমস্যার জন্য, 5 থেকে 10 স্তরটি বোঝায়।
ছোট ফিল্টার ব্যবহার করুন। সাধারণত 3x3 ফিল্টার সর্বত্র ভাল।
1x1 ফিল্টারগুলিও ব্যবহার করা যেতে পারে এবং সস্তা। তারা চ্যানেলগুলির রৈখিক সংমিশ্রণগুলি গণনা করে আসলে কিছু "ফিল্টার" করে না। বাস্তব ফিল্টার সহ তাদের বিকল্প করুন। (পরবর্তী বিভাগে "1x1 কনভোলিউশন" সম্পর্কে আরও কিছু))
এর মতো শ্রেণিবিন্যাস সমস্যার জন্য, সর্বাধিক পুলিং স্তরগুলি (বা স্ট্রাইড> 1 সহ কনভোলিউশন) সহ প্রায়শই ডাউনসাম্পল। ফুলটি কোথায় রয়েছে সেদিকে আপনি যত্নশীল হবেন না, কেবলমাত্র এটি গোলাপ বা ড্যান্ডেলিয়ন তাই এক্স এবং ওয়াই তথ্য হারাতে গুরুত্বপূর্ণ নয় এবং ছোট অঞ্চলগুলিকে ফিল্টার করা সস্তা।
ফিল্টারগুলির সংখ্যা সাধারণত নেটওয়ার্কের শেষে ক্লাসের সংখ্যার সাথে সমান হয়ে যায় (কেন? নীচে "গ্লোবাল গড় পুলিং" কৌশলটি দেখুন)। আপনি যদি শত শত শ্রেণিতে শ্রেণিবদ্ধ করেন তবে পরপর স্তরগুলিতে ফিল্টার গণনা ক্রমান্বয়ে বাড়ান। 5 টি ক্লাস সহ ফুলের ডেটাসেটের জন্য, কেবল 5 টি ফিল্টার সহ ফিল্টারিং যথেষ্ট হবে না। আপনি বেশিরভাগ স্তরগুলিতে একই ফিল্টার গণনা ব্যবহার করতে পারেন, উদাহরণস্বরূপ 32 এবং এটি শেষের দিকে হ্রাস করতে পারেন।
চূড়ান্ত ঘন স্তর (গুলি) ব্যয়বহুল। এটি/তাদের একত্রিত সমস্ত সমঝোতা স্তরগুলির চেয়ে বেশি ওজন থাকতে পারে। উদাহরণস্বরূপ, এমনকি 24x24x10 ডেটা পয়েন্টের শেষ ডেটা কিউব থেকে খুব যুক্তিসঙ্গত আউটপুট থাকা সত্ত্বেও, একটি 100 নিউরন ঘন স্তরটির জন্য 24x24x10x100 = 576,000 ওজনের ব্যয় হবে !!! চিন্তাশীল হওয়ার চেষ্টা করুন, বা বিশ্বব্যাপী গড় পুলিংয়ের চেষ্টা করুন (নীচে দেখুন)।

বিশ্বব্যাপী গড় পুলিং

একটি কনভোলিউশনাল নিউরাল নেটওয়ার্কের শেষে একটি ব্যয়বহুল ঘন স্তর ব্যবহার করার পরিবর্তে, আপনি আগত ডেটা "কিউব" কে আপনার ক্লাস হিসাবে যতগুলি অংশে বিভক্ত করতে পারেন, তাদের মানগুলি গড় গড় এবং সফটম্যাক্স অ্যাক্টিভেশন ফাংশনের মাধ্যমে এগুলি খাওয়াতে পারেন। শ্রেণিবিন্যাসের মাথা তৈরির এই উপায়টির জন্য 0 ওজনের ব্যয় হয়। কেরাসে, সিনট্যাক্সটি হ'ল tf.keras.layers.GlobalAveragePooling2D().

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

সমাধান

এখানে সমাধান নোটবুক। আপনি আটকে থাকলে আপনি এটি ব্যবহার করতে পারেন।

Keras_Flowers_TPU (solution).ipynb

আমরা কভার করেছি কি

🤔 কনভোলিউশনাল স্তরগুলির সাথে খেলেছে
Max সর্বোচ্চ পুলিং, স্ট্রাইডস, গ্লোবাল গড় পুলিং, ... নিয়ে পরীক্ষিত ...
P টিপিইউতে দ্রুত একটি বাস্তব-বিশ্বের মডেলটিতে পুনরাবৃত্তি

আপনার মাথায় এই চেকলিস্টটি দিয়ে যেতে দয়া করে কিছুক্ষণ সময় নিন।

10. [তথ্য] আধুনিক কনভোলিউশনাল আর্কিটেকচার

সংক্ষেপে

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

চিত্র: একটি সমঝোতা "মডিউল"। এই মুহুর্তে সেরা কি? একটি সর্বোচ্চ-পুল স্তর পরে 1x1 কনভোলিউশনাল স্তর বা স্তরগুলির একটি ভিন্ন সংমিশ্রণ রয়েছে? তাদের সমস্ত চেষ্টা করে দেখুন, ফলাফলগুলি একত্রিত করুন এবং নেটওয়ার্কটি সিদ্ধান্ত নিতে দিন। ডানদিকে: এই জাতীয় মডিউলগুলি ব্যবহার করে " ইনসেপশন " কনভোলিউশনাল আর্কিটেকচার।

কেরাসে, এমন মডেলগুলি তৈরি করতে যেখানে ডেটা প্রবাহ শাখা এবং বাইরে শাখা করতে পারে, আপনাকে "কার্যকরী" মডেল শৈলী ব্যবহার করতে হবে। এখানে একটি উদাহরণ:

l = tf.keras.layers # syntax shortcut

y = l.Conv2D(filters=32, kernel_size=3, padding='same',
             activation='relu', input_shape=[192, 192, 3])(x) # x=input image

# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation

# many more layers ...

# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)

অন্যান্য সস্তা কৌশল

ছোট 3x3 ফিল্টার

এই চিত্রটিতে, আপনি টানা দুটি 3x3 ফিল্টারের ফলাফল দেখতে পান। কোন ডেটা পয়েন্টগুলি ফলাফলের জন্য অবদান রেখেছিল তা ফিরে দেখার চেষ্টা করুন: এই দুটি পরপর 3x3 ফিল্টার 5x5 অঞ্চলের কিছু সংমিশ্রণ গণনা করে। এটি ঠিক একই সংমিশ্রণ নয় যে 5x5 ফিল্টারটি গণনা করবে তবে এটি চেষ্টা করার মতো কারণ কারণ পরপর দুটি 3x3 ফিল্টার একক 5x5 ফিল্টারের চেয়ে সস্তা।

1x1 কনভোলিউশন?

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

11. স্কিজেনেট

এই ধারণাগুলি একসাথে রাখার একটি সহজ উপায় "স্কিজেনেট" কাগজে প্রদর্শিত হয়েছে। লেখকরা কেবলমাত্র 1x1 এবং 3x3 কনভোলিউশনাল স্তরগুলি ব্যবহার করে একটি খুব সাধারণ কনভোলিউশনাল মডিউল ডিজাইনের পরামর্শ দেন।

চিত্র: "ফায়ার মডিউল" এর উপর ভিত্তি করে স্কিজেনেট আর্কিটেকচার। তারা একটি 1x1 স্তর বিকল্প করে যা উল্লম্ব মাত্রায় আগত ডেটাগুলিকে "চেপে" দেয় এবং তারপরে দুটি সমান্তরাল 1x1 এবং 3x3 কনভোলিউশনাল স্তরগুলি অনুসরণ করে যা আবার ডেটার গভীরতা "প্রসারিত" করে।

হাতে-কলমে

আপনার আগের নোটবুকটি চালিয়ে যান এবং একটি স্কিজেনেট-অনুপ্রাণিত কনভোলিউশনাল নিউরাল নেটওয়ার্ক তৈরি করুন। আপনাকে মডেল কোডটি কেরাস "ফাংশনাল স্টাইল" এ পরিবর্তন করতে হবে।

Keras_Flowers_TPU (playground).ipynb

অতিরিক্ত তথ্য

এই অনুশীলনের পক্ষে একটি স্কিজেনেট মডিউলটির জন্য একটি সহায়ক ফাংশন সংজ্ঞায়িত করা কার্যকর হবে:

def fire(x, squeeze, expand):
  y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
  y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
  y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
  return tf.keras.layers.concatenate([y1, y3])

# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
  return lambda x: fire(x, squeeze, expand)

# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)

এবার উদ্দেশ্যটি হ'ল 80% নির্ভুলতা হিট করা।

চেষ্টা করার জিনিস

একটি একক কনভোলিউশনাল স্তর দিয়ে শুরু করুন, তারপরে " fire_modules " দিয়ে অনুসরণ করুন, MaxPooling2D(pool_size=2) স্তরগুলির সাথে পরিবর্তিত করুন। আপনি নেটওয়ার্কে 2 থেকে 4 ম্যাক্স পুলিং স্তরগুলি এবং সর্বাধিক পুলিং স্তরগুলির মধ্যে 1, 2 বা 3 টি টানা ফায়ার মডিউল সহ পরীক্ষা করতে পারেন।

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

এখানে একটি উদাহরণ:

x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB

y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)

model = tf.keras.Model(x, y)

এই মুহুর্তে, আপনি লক্ষ্য করতে পারেন যে আপনার পরীক্ষাগুলি এত ভাল চলছে না এবং 80% নির্ভুলতার উদ্দেশ্যটি দূরবর্তী বলে মনে হচ্ছে। আরও কয়েকটি সস্তা কৌশলগুলির জন্য সময়।

ব্যাচের স্বাভাবিককরণ

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

y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context

গতিবেগের প্যারামিটারটি এর ডিফল্ট মান থেকে 0.99 এর 0.9 এ হ্রাস করতে হবে কারণ আমাদের ডেটাসেটটি ছোট। আপাতত এই বিশদটি মনে করবেন না।

তথ্য বৃদ্ধি

স্যাচুরেশন পরিবর্তনের বাম-ডান ফ্লিপগুলির মতো সহজ রূপান্তরগুলির সাথে ডেটা বাড়িয়ে আপনি আরও কয়েকটি শতাংশ পয়েন্ট পাবেন:

TF.DATA.DATASET API এর সাথে টেনসরফ্লোতে এটি করা খুব সহজ। আপনার ডেটার জন্য একটি নতুন রূপান্তর ফাংশন সংজ্ঞায়িত করুন:

def data_augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_saturation(image, lower=0, upper=2)
    return image, label

তারপরে এটি আপনার চূড়ান্ত ডেটা ট্রান্সফর্মেশন (সেল "প্রশিক্ষণ এবং বৈধতা ডেটাসেটস", ফাংশন "get_batched_dataset" ফাংশন ব্যবহার করুন:

dataset = dataset.repeat() # existing line
# insert this
if augment_data:
  dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line

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

35 ইপোকগুলিতে 80% নির্ভুলতা এখন নাগালের মধ্যে থাকা উচিত।

সমাধান

এখানে সমাধান নোটবুক। আপনি আটকে থাকলে আপনি এটি ব্যবহার করতে পারেন।

Keras_Flowers_TPU_squeezenet.ipynb

আমরা কভার করেছি কি

🤔 কেরাস "ফাংশনাল স্টাইল" মডেল
🤓 স্কিজেনেট আর্কিটেকচার
TF tf.data.datset এর সাথে ডেটা বৃদ্ধি

আপনার মাথায় এই চেকলিস্টটি দিয়ে যেতে দয়া করে কিছুক্ষণ সময় নিন।

12. এক্সসেপশন সূক্ষ্ম সুরযুক্ত

পৃথকযোগ্য কনভোলিউশন

কনভোলিউশনাল স্তরগুলি বাস্তবায়নের একটি ভিন্ন উপায় সম্প্রতি জনপ্রিয়তা অর্জন করেছিল: গভীরতা-ধ্রুবক কনভোলিউশন। আমি জানি, এটি একটি মুখী, তবে ধারণাটি বেশ সহজ। এগুলি টেনসরফ্লো এবং কেরাসে tf.keras.layers.SeparableConv2D হিসাবে প্রয়োগ করা হয়।

একটি পৃথকযোগ্য কনভোলিউশন চিত্রটিতে একটি ফিল্টারও চালায় তবে এটি ইনপুট চিত্রের প্রতিটি চ্যানেলের জন্য ওজনের একটি স্বতন্ত্র সেট ব্যবহার করে। এটি একটি "1x1 কনভোলিউশন" এর সাথে অনুসরণ করে, ফিল্টারযুক্ত চ্যানেলগুলির একটি ওজনযুক্ত যোগফলের ফলে ডট পণ্যগুলির একটি সিরিজ। প্রতিবার নতুন ওজন সহ, চ্যানেলগুলির অনেকগুলি ওজনযুক্ত পুনঃসংযোগগুলি প্রয়োজনীয় হিসাবে গণনা করা হয়।

চিত্র: পৃথকযোগ্য কনভোলিউশন। পর্ব 1: প্রতিটি চ্যানেলের জন্য পৃথক ফিল্টার সহ কনভোলিউশন। দ্বিতীয় ধাপ: চ্যানেলগুলির লিনিয়ার পুনঃসংযোগগুলি। আউটপুট চ্যানেলগুলির কাঙ্ক্ষিত সংখ্যক না হওয়া পর্যন্ত ওজনের একটি নতুন সেট দিয়ে পুনরাবৃত্তি করা। প্রথমবারের মতো নতুন ওজন সহ প্রথম পর্যায়টি পুনরাবৃত্তি করা যেতে পারে তবে বাস্তবে এটি খুব কমই হয়।

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

এগুলি নিয়মিত কনভোলিউশনের তুলনায় সস্তা এবং অনুশীলনে ঠিক ততটাই কার্যকর বলে প্রমাণিত হয়েছে। উপরে বর্ণিত উদাহরণের জন্য ওজন গণনা এখানে:

কনভোলিউশনাল স্তর: 4 x 4 x 3 x 5 = 240

পৃথকযোগ্য কনভোলিউশনাল স্তর: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

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

হাতে-কলমে

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

Keras Flowers transfer learning (playground).ipynb

লক্ষ্য: নির্ভুলতা> 95% (না, গুরুত্ব সহকারে, এটি সম্ভব!)

এটি চূড়ান্ত অনুশীলন, এটির জন্য আরও কিছুটা কোড এবং ডেটা বিজ্ঞানের কাজ প্রয়োজন।

সূক্ষ্ম-টিউনিং সম্পর্কিত অতিরিক্ত তথ্য

এক্সসেপশন টিএফ.কারাস.অ্যাপ্লিকেশনে স্ট্যান্ডার্ড প্রাক-প্রশিক্ষিত মডেলগুলিতে উপলব্ধ।* এবার সমস্ত ওজনকে প্রশিক্ষণযোগ্য রেখে যেতে ভুলবেন না।

pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
                                                  include_top=False)
pretrained_model.trainable = True

কোনও মডেল সূক্ষ্ম-সুর করার সময় ভাল ফলাফল পেতে আপনাকে শেখার হারের দিকে মনোযোগ দিতে হবে এবং র‌্যাম্প-আপ পিরিয়ড সহ একটি শেখার হারের সময়সূচী ব্যবহার করতে হবে। এই মত:

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

কেরাসে, শেখার হারটি একটি কলব্যাকের মাধ্যমে নির্দিষ্ট করা হয়েছে যাতে আপনি প্রতিটি যুগের জন্য উপযুক্ত শিক্ষার হার গণনা করতে পারেন। কেরাস প্রতিটি যুগের জন্য অপ্টিমাইজারে সঠিক শিক্ষার হারটি পাস করবে।

def lr_fn(epoch):
  lr = ...
  return lr

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)

model.fit(..., callbacks=[lr_callback])

সমাধান

এখানে সমাধান নোটবুক। আপনি আটকে থাকলে আপনি এটি ব্যবহার করতে পারেন।

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

আমরা কভার করেছি কি

🤔 গভীরতা-ধ্রুবক সমঝোতা
🤓 শেখার হারের সময়সূচী
😈 একটি প্রাক-প্রশিক্ষিত মডেল সূক্ষ্ম-সুর করা।

আপনার মাথায় এই চেকলিস্টটি দিয়ে যেতে দয়া করে কিছুক্ষণ সময় নিন।

13. অভিনন্দন!

আপনি আপনার প্রথম আধুনিক কনভোলিউশনাল নিউরাল নেটওয়ার্ক তৈরি করেছেন এবং এটি 90% + নির্ভুলতার প্রশিক্ষণ দিয়েছেন, টিপিইউগুলির জন্য কেবল কয়েক মিনিটের মধ্যেই ক্রমাগত প্রশিক্ষণে পুনরাবৃত্তি করে।

অনুশীলনে টিপিইউ

টিপিইউ এবং জিপিইউগুলি গুগল ক্লাউডের ভার্টেক্স এআইতে উপলব্ধ:

অবশেষে, আমরা প্রতিক্রিয়া পছন্দ করি। আপনি যদি এই ল্যাবটিতে কিছু ভুল দেখেন বা আপনি যদি মনে করেন এটির উন্নতি করা উচিত তবে দয়া করে আমাদের বলুন। গিটহাব ইস্যুগুলির মাধ্যমে প্রতিক্রিয়া সরবরাহ করা যেতে পারে [ প্রতিক্রিয়া লিঙ্ক ]।

মার্টিন গারনার আইডি ছোট.জেপিজি
লেখক: মার্টিন গারনার
টুইটার: @মার্টিন_গর্নার