এই কোডল্যাব সম্পর্কে
1. তুমি শুরু করার আগে
এই কোডল্যাবে আপনি ঘোড়া এবং মানুষের ছবি শ্রেণীবদ্ধ করতে কনভল্যুশন ব্যবহার করবেন। আপনি একটি CNN তৈরি করতে এই ল্যাবে টেনসরফ্লো ব্যবহার করবেন যা ঘোড়া এবং মানুষের ছবি চিনতে এবং তাদের শ্রেণীবদ্ধ করতে প্রশিক্ষিত।
পূর্বশর্ত
আপনি যদি আগে কখনো TensorFlow-এর সাথে কনভোলিউশন তৈরি না করে থাকেন, তাহলে আপনি Build convolutions সম্পূর্ণ করতে এবং পুলিং কোডল্যাব করতে চাইতে পারেন, যেখানে আমরা কনভোল্যুশন এবং পুলিং প্রবর্তন করি এবং কম্পিউটারের দৃষ্টিশক্তি বাড়াতে কনভোল্যুশনাল নিউরাল নেটওয়ার্ক (CNN) তৈরি করি, যেখানে আমরা আলোচনা করি কিভাবে কম্পিউটার তৈরি করা যায়। ছবি চিনতে আরও দক্ষ।
আপনি কি শিখবেন
- একটি চিত্রের বৈশিষ্ট্যগুলি সনাক্ত করতে কম্পিউটারগুলিকে কীভাবে প্রশিক্ষণ দেওয়া যায় যেখানে বিষয় স্পষ্ট নয়
আপনি কি নির্মাণ করবেন
- একটি কনভোল্যুশনাল নিউরাল নেটওয়ার্ক যা ঘোড়ার ছবি এবং মানুষের ছবির মধ্যে পার্থক্য করতে পারে
আপনি কি প্রয়োজন হবে
আপনি Colab- এ চলমান বাকি কোডল্যাবের কোড খুঁজে পেতে পারেন।
আপনাকে টেনসরফ্লো ইনস্টল করতে হবে, এবং আগের কোডল্যাবে আপনি যে লাইব্রেরিগুলি ইনস্টল করেছেন।
2. শুরু করা: ডেটা অর্জন করুন
আপনি একটি ঘোড়া-বা-মানুষের শ্রেণিবিন্যাস তৈরি করে এটি করবেন যা আপনাকে বলবে যে প্রদত্ত ছবিতে একটি ঘোড়া বা মানুষ রয়েছে কিনা, যেখানে নেটওয়ার্কটি এমন বৈশিষ্ট্যগুলি সনাক্ত করতে প্রশিক্ষিত হয় যা নির্ধারণ করে যে কোনটি। প্রশিক্ষণ নেওয়ার আগে আপনাকে ডেটার কিছু প্রক্রিয়াকরণ করতে হবে।
প্রথমে ডেটা ডাউনলোড করুন:
!wget --no-check-certificate https://storage.googleapis.com/laurencemoroney-blog.appspot.com/horse-or-human.zip -O /tmp/horse-or-human.zip
নিম্নলিখিত পাইথন কোডটি অপারেটিং সিস্টেম লাইব্রেরি ব্যবহার করার জন্য ওএস লাইব্রেরি ব্যবহার করবে, আপনাকে ফাইল সিস্টেম এবং জিপ ফাইল লাইব্রেরিতে অ্যাক্সেস দেবে, তাই আপনাকে ডেটা আনজিপ করার অনুমতি দেবে।
import os
import zipfile
local_zip = '/tmp/horse-or-human.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp/horse-or-human')
zip_ref.close()
জিপ ফাইলের বিষয়বস্তু বেস ডিরেক্টরি /tmp/horse-or-human এ বের করা হয়, যেটিতে ঘোড়া এবং মানুষের সাবডিরেক্টরি রয়েছে।
সংক্ষেপে, প্রশিক্ষণ সেট হল সেই ডেটা যা নিউরাল নেটওয়ার্ক মডেলকে বলতে ব্যবহৃত হয় যে "এটি একটি ঘোড়া দেখতে কেমন" এবং "একজন মানুষ দেখতে এইরকম।"
3. ডেটা লেবেল এবং প্রস্তুত করতে ইমেজ জেনারেটর ব্যবহার করুন
আপনি স্পষ্টভাবে ঘোড়া বা মানুষ হিসাবে ছবি লেবেল না.
পরে আপনি একটি ImageDataGenerator নামক কিছু ব্যবহার করা হচ্ছে দেখতে পাবেন। এটি সাবডিরেক্টরি থেকে ছবি পড়ে এবং সেই সাবডিরেক্টরির নাম থেকে স্বয়ংক্রিয়ভাবে লেবেল করে। উদাহরণস্বরূপ, আপনার কাছে একটি প্রশিক্ষণ ডিরেক্টরি রয়েছে যেখানে একটি ঘোড়ার ডিরেক্টরি এবং একটি মানুষের ডিরেক্টরি রয়েছে। ImageDataGenerator আপনার জন্য ছবিগুলিকে যথাযথভাবে লেবেল করবে, একটি কোডিং ধাপ কমিয়ে দেবে।
সেই ডিরেক্টরিগুলির প্রতিটি সংজ্ঞায়িত করুন।
# Directory with our training horse pictures
train_horse_dir = os.path.join('/tmp/horse-or-human/horses')
# Directory with our training human pictures
train_human_dir = os.path.join('/tmp/horse-or-human/humans')
এখন, ঘোড়া এবং মানুষের প্রশিক্ষণ ডিরেক্টরিতে ফাইলের নামগুলি দেখতে কেমন তা দেখুন:
train_horse_names = os.listdir(train_horse_dir)
print(train_horse_names[:10])
train_human_names = os.listdir(train_human_dir)
print(train_human_names[:10])
ডিরেক্টরিতে ঘোড়া এবং মানুষের ছবির মোট সংখ্যা খুঁজুন:
print('total training horse images:', len(os.listdir(train_horse_dir)))
print('total training human images:', len(os.listdir(train_human_dir)))
4. তথ্য অন্বেষণ
সেগুলি কেমন দেখাচ্ছে সে সম্পর্কে আরও ভাল ধারণা পেতে কয়েকটি ছবি দেখুন।
প্রথমে, matplot প্যারামিটারগুলি কনফিগার করুন:
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4
# Index for iterating over images
pic_index = 0
এখন, আটটি ঘোড়ার ছবি এবং আটটি মানুষের ছবির একটি ব্যাচ প্রদর্শন করুন। আপনি প্রতিবার একটি নতুন ব্যাচ দেখতে সেলটি পুনরায় চালাতে পারেন।
# Set up matplotlib fig, and size it to fit 4x4 pics
fig = plt.gcf()
fig.set_size_inches(ncols * 4, nrows * 4)
pic_index += 8
next_horse_pix = [os.path.join(train_horse_dir, fname)
for fname in train_horse_names[pic_index-8:pic_index]]
next_human_pix = [os.path.join(train_human_dir, fname)
for fname in train_human_names[pic_index-8:pic_index]]
for i, img_path in enumerate(next_horse_pix+next_human_pix):
# Set up subplot; subplot indices start at 1
sp = plt.subplot(nrows, ncols, i + 1)
sp.axis('Off') # Don't show axes (or gridlines)
img = mpimg.imread(img_path)
plt.imshow(img)
plt.show()
এখানে ঘোড়া এবং মানুষকে বিভিন্ন ভঙ্গি এবং অভিযোজনে দেখানো কিছু উদাহরণ চিত্র রয়েছে:
5. মডেল সংজ্ঞায়িত করুন
মডেল সংজ্ঞায়িত করা শুরু করুন।
TensorFlow আমদানি করে শুরু করুন:
import tensorflow as tf
তারপরে, কনভোলিউশনাল লেয়ারগুলি যোগ করুন এবং ঘনভাবে সংযুক্ত স্তরগুলিতে ফিড করার জন্য চূড়ান্ত ফলাফলটিকে সমতল করুন। অবশেষে, ঘনভাবে সংযুক্ত স্তর যোগ করুন।
মনে রাখবেন যে আপনি একটি দ্বি-শ্রেণীর শ্রেণিবিন্যাসের সমস্যা (একটি বাইনারি শ্রেণিবিন্যাসের সমস্যা) সম্মুখীন হওয়ার কারণে আপনি একটি সিগমায়েড অ্যাক্টিভেশনের মাধ্যমে আপনার নেটওয়ার্কটি শেষ করবেন যাতে আপনার নেটওয়ার্কের আউটপুট 0 এবং 1 এর মধ্যে একটি একক স্কেলার হবে, সম্ভাব্যতা এনকোডিং বর্তমান চিত্রটি ক্লাস 1 (শ্রেণী 0 এর বিপরীতে)।
model = tf.keras.models.Sequential([
# Note the input shape is the desired size of the image 300x300 with 3 bytes color
# This is the first convolution
tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(300, 300, 3)),
tf.keras.layers.MaxPooling2D(2, 2),
# The second convolution
tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
# The third convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
# The fourth convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
# The fifth convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
# Flatten the results to feed into a DNN
tf.keras.layers.Flatten(),
# 512 neuron hidden layer
tf.keras.layers.Dense(512, activation='relu'),
# Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans')
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.summary() মেথড কল নেটওয়ার্কের একটি সারাংশ প্রিন্ট করে।
model.summary()
আপনি এখানে ফলাফল দেখতে পারেন:
Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 298, 298, 16) 448 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 149, 149, 16) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 147, 147, 32) 4640 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 73, 73, 32) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 71, 71, 64) 18496 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 35, 35, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 33, 33, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 16, 16, 64) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 14, 14, 64) 36928 _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 7, 7, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 3136) 0 _________________________________________________________________ dense (Dense) (None, 512) 1606144 _________________________________________________________________ dense_1 (Dense) (None, 1) 513 ================================================================= Total params: 1,704,097 Trainable params: 1,704,097 Non-trainable params: 0
আউটপুট আকৃতি কলাম দেখায় কিভাবে আপনার বৈশিষ্ট্য মানচিত্রের আকার প্রতিটি ধারাবাহিক স্তরে বিকশিত হয়। প্যাডিংয়ের কারণে কনভোলিউশন লেয়ার ফিচার ম্যাপের আকার কিছুটা কমিয়ে দেয় এবং প্রতিটি পুলিং লেয়ারের মাত্রা অর্ধেক করে দেয়।
6. মডেল কম্পাইল করুন
পরবর্তী, মডেল প্রশিক্ষণের জন্য নির্দিষ্টকরণ কনফিগার করুন। binary_crossentropy ক্ষতির সাথে আপনার মডেলকে প্রশিক্ষণ দিন কারণ এটি একটি বাইনারি শ্রেণিবিন্যাস সমস্যা এবং আপনার চূড়ান্ত সক্রিয়করণ একটি সিগমায়েড। (লস মেট্রিক্সের রিফ্রেশারের জন্য, ML-এ অবতরণ দেখুন।) 0.001 এর শেখার হার সহ rmsprop অপ্টিমাইজার ব্যবহার করুন। প্রশিক্ষণের সময়, শ্রেণীবিভাগের নির্ভুলতা নিরীক্ষণ করুন।
from tensorflow.keras.optimizers import RMSprop
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['acc'])
7. জেনারেটর থেকে মডেল প্রশিক্ষণ
ডেটা জেনারেটর সেট আপ করুন যা আপনার উত্স ফোল্ডারে ছবিগুলি পড়ে, সেগুলিকে float32 টেনসরগুলিতে রূপান্তর করে এবং আপনার নেটওয়ার্কে তাদের (তাদের লেবেল সহ) ফিড করে৷
আপনার কাছে প্রশিক্ষণের চিত্রগুলির জন্য একটি জেনারেটর এবং একটি বৈধকরণ চিত্রগুলির জন্য থাকবে৷ আপনার জেনারেটরগুলি 300x300 আকারের চিত্রের ব্যাচ এবং তাদের লেবেল (বাইনারী) দেবে।
আপনি ইতিমধ্যেই জানেন যে, নিউরাল নেটওয়ার্কে যে ডেটা যায় তা সাধারণত কিছু উপায়ে স্বাভাবিক করা উচিত যাতে এটি নেটওয়ার্ক দ্বারা প্রক্রিয়াকরণের জন্য আরও উপযুক্ত করে তোলে। (এটি একটি CNN-এ কাঁচা পিক্সেল খাওয়ানো অস্বাভাবিক।) আপনার ক্ষেত্রে, আপনি পিক্সেল মানগুলিকে [0, 1] পরিসরে স্বাভাবিক করার মাধ্যমে আপনার ছবিগুলিকে প্রিপ্রসেস করবেন (মূলত সমস্ত মান [0, 255] রেঞ্জের মধ্যে থাকে )
কেরাসে, এটি রিস্কেল প্যারামিটার ব্যবহার করে keras.preprocessing.image.ImageDataGenerator ক্লাসের মাধ্যমে করা যেতে পারে। সেই ImageDataGenerator ক্লাসটি আপনাকে .flow(data, labels) বা .flow_from_directory(ডিরেক্টরি) এর মাধ্যমে অগমেন্টেড ইমেজ ব্যাচের (এবং তাদের লেবেল) জেনারেটরকে ইনস্ট্যান্টিয়েট করতে দেয়। সেই জেনারেটরগুলি কেরাস মডেল পদ্ধতিগুলির সাথে ব্যবহার করা যেতে পারে যা ডেটা জেনারেটরগুলিকে ইনপুট হিসাবে গ্রহণ করে: fit_generator , evaluate_generator এবং predict_generator ৷
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# All images will be rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1./255)
# Flow training images in batches of 128 using train_datagen generator
train_generator = train_datagen.flow_from_directory(
'/tmp/horse-or-human/', # This is the source directory for training images
target_size=(300, 300), # All images will be resized to 150x150
batch_size=128,
# Since we use binary_crossentropy loss, we need binary labels
class_mode='binary')
8. প্রশিক্ষণ দিন
15 যুগের জন্য ট্রেন। (এটি চালানোর জন্য কয়েক মিনিট সময় লাগতে পারে।)
history = model.fit(
train_generator,
steps_per_epoch=8,
epochs=15,
verbose=1)
প্রতি যুগের মানগুলি নোট করুন।
ক্ষতি এবং সঠিকতা প্রশিক্ষণের অগ্রগতির একটি বড় ইঙ্গিত। এটি প্রশিক্ষণের ডেটার শ্রেণীবিভাগ হিসাবে একটি অনুমান করছে, এবং তারপর এটি পরিচিত লেবেলের বিরুদ্ধে পরিমাপ করছে, ফলাফল গণনা করছে। নির্ভুলতা সঠিক অনুমানের অংশ।
Epoch 1/15 9/9 [==============================] - 9s 1s/step - loss: 0.8662 - acc: 0.5151 Epoch 2/15 9/9 [==============================] - 8s 927ms/step - loss: 0.7212 - acc: 0.5969 Epoch 3/15 9/9 [==============================] - 8s 921ms/step - loss: 0.6612 - acc: 0.6592 Epoch 4/15 9/9 [==============================] - 8s 925ms/step - loss: 0.3135 - acc: 0.8481 Epoch 5/15 9/9 [==============================] - 8s 919ms/step - loss: 0.4640 - acc: 0.8530 Epoch 6/15 9/9 [==============================] - 8s 896ms/step - loss: 0.2306 - acc: 0.9231 Epoch 7/15 9/9 [==============================] - 8s 915ms/step - loss: 0.1464 - acc: 0.9396 Epoch 8/15 9/9 [==============================] - 8s 935ms/step - loss: 0.2663 - acc: 0.8919 Epoch 9/15 9/9 [==============================] - 8s 883ms/step - loss: 0.0772 - acc: 0.9698 Epoch 10/15 9/9 [==============================] - 9s 951ms/step - loss: 0.0403 - acc: 0.9805 Epoch 11/15 9/9 [==============================] - 8s 891ms/step - loss: 0.2618 - acc: 0.9075 Epoch 12/15 9/9 [==============================] - 8s 902ms/step - loss: 0.0434 - acc: 0.9873 Epoch 13/15 9/9 [==============================] - 8s 904ms/step - loss: 0.0187 - acc: 0.9932 Epoch 14/15 9/9 [==============================] - 9s 951ms/step - loss: 0.0974 - acc: 0.9649 Epoch 15/15 9/9 [==============================] - 8s 877ms/step - loss: 0.2859 - acc: 0.9338
9. মডেল পরীক্ষা করুন
এখন আসলে মডেল ব্যবহার করে একটি ভবিষ্যদ্বাণী চালান। কোডটি আপনাকে আপনার ফাইল সিস্টেম থেকে এক বা একাধিক ফাইল বেছে নেওয়ার অনুমতি দেবে। এটি তারপরে সেগুলি আপলোড করবে এবং মডেলের মাধ্যমে সেগুলি চালাবে, বস্তুটি ঘোড়া বা মানুষ কিনা তা নির্দেশ করবে।
আপনি ইন্টারনেট থেকে আপনার ফাইল সিস্টেমে ছবি ডাউনলোড করে দেখতে পারেন! মনে রাখবেন যে আপনি হয়তো দেখতে পাচ্ছেন যে প্রশিক্ষণের নির্ভুলতা 99% এর উপরে থাকা সত্ত্বেও নেটওয়ার্কটি অনেক ভুল করে।
এটি ওভারফিটিং নামক কিছুর কারণে, যার মানে হল যে নিউরাল নেটওয়ার্ক খুব সীমিত ডেটার সাথে প্রশিক্ষিত হয় (প্রতিটি শ্রেণীর মাত্র 500টি চিত্র রয়েছে)। তাই প্রশিক্ষণ সেটের মতো দেখতে ছবিগুলিকে চিনতে এটি খুব ভাল, তবে প্রশিক্ষণ সেটে নেই এমন চিত্রগুলিতে এটি অনেক ব্যর্থ হতে পারে।
এটি একটি ডেটাপয়েন্ট প্রমাণ করে যে আপনি যত বেশি ডেটা প্রশিক্ষণ দেবেন, আপনার চূড়ান্ত নেটওয়ার্ক তত ভাল হবে!
ইমেজ অগমেন্টেশন নামে কিছু সহ সীমিত ডেটা থাকা সত্ত্বেও আপনার প্রশিক্ষণকে আরও ভাল করতে ব্যবহার করা যেতে পারে এমন অনেক কৌশল রয়েছে, তবে এটি এই কোডল্যাবের সুযোগের বাইরে।
import numpy as np
from google.colab import files
from keras.preprocessing import image
uploaded = files.upload()
for fn in uploaded.keys():
# predicting images
path = '/content/' + fn
img = image.load_img(path, target_size=(300, 300))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
images = np.vstack([x])
classes = model.predict(images, batch_size=10)
print(classes[0])
if classes[0]>0.5:
print(fn + " is a human")
else:
print(fn + " is a horse")
উদাহরণস্বরূপ, বলুন যে আপনি এই ছবিটি দিয়ে পরীক্ষা করতে চান:
কোলাব কী উত্পাদন করে তা এখানে:
এটি একটি কার্টুন গ্রাফিক হওয়া সত্ত্বেও, এটি এখনও সঠিকভাবে শ্রেণীবদ্ধ করে।
নিম্নলিখিত চিত্রটিও সঠিকভাবে শ্রেণীবদ্ধ করে:
আপনার নিজের কিছু ছবি চেষ্টা করুন এবং অন্বেষণ!
10. মধ্যবর্তী উপস্থাপনা কল্পনা করুন
আপনার সিএনএন কী ধরণের বৈশিষ্ট্য শিখেছে তা অনুভব করতে, একটি মজার জিনিস হল একটি ইনপুট সিএনএন-এর মাধ্যমে যাওয়ার সাথে সাথে কীভাবে রূপান্তরিত হয় তা কল্পনা করা।
প্রশিক্ষণ সেট থেকে একটি এলোমেলো চিত্র বাছাই করুন, তারপর একটি চিত্র তৈরি করুন যেখানে প্রতিটি সারি একটি স্তরের আউটপুট এবং সারির প্রতিটি চিত্র সেই আউটপুট বৈশিষ্ট্য মানচিত্রে একটি নির্দিষ্ট ফিল্টার। বিভিন্ন প্রশিক্ষণ চিত্রের জন্য মধ্যবর্তী উপস্থাপনা তৈরি করতে সেই ঘরটি পুনরায় চালান।
import numpy as np
import random
from tensorflow.keras.preprocessing.image import img_to_array, load_img
# Let's define a new Model that will take an image as input, and will output
# intermediate representations for all layers in the previous model after
# the first.
successive_outputs = [layer.output for layer in model.layers[1:]]
#visualization_model = Model(img_input, successive_outputs)
visualization_model = tf.keras.models.Model(inputs = model.input, outputs = successive_outputs)
# Let's prepare a random input image from the training set.
horse_img_files = [os.path.join(train_horse_dir, f) for f in train_horse_names]
human_img_files = [os.path.join(train_human_dir, f) for f in train_human_names]
img_path = random.choice(horse_img_files + human_img_files)
img = load_img(img_path, target_size=(300, 300)) # this is a PIL image
x = img_to_array(img) # Numpy array with shape (150, 150, 3)
x = x.reshape((1,) + x.shape) # Numpy array with shape (1, 150, 150, 3)
# Rescale by 1/255
x /= 255
# Let's run our image through our network, thus obtaining all
# intermediate representations for this image.
successive_feature_maps = visualization_model.predict(x)
# These are the names of the layers, so can have them as part of our plot
layer_names = [layer.name for layer in model.layers]
# Now let's display our representations
for layer_name, feature_map in zip(layer_names, successive_feature_maps):
if len(feature_map.shape) == 4:
# Just do this for the conv / maxpool layers, not the fully-connected layers
n_features = feature_map.shape[-1] # number of features in feature map
# The feature map has shape (1, size, size, n_features)
size = feature_map.shape[1]
# We will tile our images in this matrix
display_grid = np.zeros((size, size * n_features))
for i in range(n_features):
# Postprocess the feature to make it visually palatable
x = feature_map[0, :, :, i]
x -= x.mean()
if x.std()>0:
x /= x.std()
x *= 64
x += 128
x = np.clip(x, 0, 255).astype('uint8')
# We'll tile each filter into this big horizontal grid
display_grid[:, i * size : (i + 1) * size] = x
# Display the grid
scale = 20. / n_features
plt.figure(figsize=(scale * n_features, scale))
plt.title(layer_name)
plt.grid(False)
plt.imshow(display_grid, aspect='auto', cmap='viridis')
এখানে উদাহরণের ফলাফল রয়েছে:
আপনি দেখতে পাচ্ছেন, আপনি চিত্রগুলির কাঁচা পিক্সেল থেকে ক্রমবর্ধমান বিমূর্ত এবং কমপ্যাক্ট উপস্থাপনাগুলিতে যান৷ নীচের দিকের উপস্থাপনাগুলি নেটওয়ার্ক কী মনোযোগ দেয় তা হাইলাইট করা শুরু করে এবং তারা কম এবং কম বৈশিষ্ট্যগুলিকে "সক্রিয় করা" দেখায়। বেশিরভাগই শূন্যে সেট করা হয়েছে। এটাকে বলে স্পারসিটি । প্রতিনিধিত্ব স্পার্সিটি গভীর শিক্ষার একটি মূল বৈশিষ্ট্য।
এই উপস্থাপনাগুলি চিত্রের মূল পিক্সেল সম্পর্কে ক্রমবর্ধমান কম তথ্য বহন করে, কিন্তু চিত্রের শ্রেণি সম্পর্কে ক্রমবর্ধমান পরিমার্জিত তথ্য বহন করে। আপনি একটি তথ্য পাতন পাইপলাইন হিসাবে একটি CNN (বা সাধারণভাবে একটি গভীর নেটওয়ার্ক) চিন্তা করতে পারেন।
11. অভিনন্দন
আপনি জটিল চিত্রগুলি উন্নত করতে CNN ব্যবহার করতে শিখেছেন। আপনার কম্পিউটার ভিশন মডেলগুলিকে কীভাবে আরও উন্নত করতে হয় তা শিখতে, অতিরিক্ত ফিটিং এড়াতে বড় ডেটাসেটের সাথে কনভোলিউশনাল নিউরাল নেটওয়ার্ক (CNN) ব্যবহার করুন ।