মাল্টি-ক্লাস শ্রেণীবিভাগ: নিউরাল নেটওয়ার্কগুলিতে সক্রিয়করণ এবং ক্ষতি কার্যকারিতা বোঝা

আমার আগের পোস্টটি শ্রেণিবিন্যাসের সমস্যাটি তৈরি করে এবং এটিকে 3 প্রকারে বিভক্ত করে (বাইনারী, মাল্টি-ক্লাস এবং মাল্টি-লেবেল) এবং "বাইনারী শ্রেণীবিভাগের কাজটি সমাধান করতে আপনার কোন সক্রিয়করণ এবং ক্ষতি ফাংশন ব্যবহার করতে হবে?" প্রশ্নের উত্তর দেয়।

এই পোস্টে, আমি একই প্রশ্নের উত্তর দেব কিন্তু বহু-শ্রেণীর শ্রেণীবিভাগের টাস্কের জন্য এবং আপনাকে একটি প্রদান করব গুগল কোল্যাবে পাইটর্চ বাস্তবায়নের উদাহরণ .

একটি মাল্টি-ক্লাস ক্লাসিফিকেশন টাস্ক সমাধান করার জন্য আপনাকে কোন সক্রিয়করণ এবং ক্ষতি ফাংশন ব্যবহার করতে হবে?

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

1 মাল্টি-ক্লাস শ্রেণীবিভাগের জন্য সক্রিয়করণ ফাংশন এবং ক্ষতি বোঝা কেন গুরুত্বপূর্ণ?

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

আপনি যদি মাল্টি-ক্লাস ক্লাসিফিকেশন সমস্যা সমাধানের জন্য সফটম্যাক্স অ্যাক্টিভেশন এবং সিই লস প্রয়োগ করার পিছনে অনুপ্রেরণা জানেন তবে আপনি আরও জটিল NN আর্কিটেকচার এবং লস ফাংশনগুলি বুঝতে এবং প্রয়োগ করতে সক্ষম হবেন।

2 মাল্টি-ক্লাস শ্রেণীবিভাগ সমস্যা প্রণয়ন

মাল্টি-ক্লাস শ্রেণীবিভাগ সমস্যাটিকে নমুনার একটি সেট হিসাবে উপস্থাপন করা যেতে পারে {(x_1, y_1), (x_2, y_2),...,(x_n, y_n)} , যেখানে x_i হল একটি এম-ডাইমেনশনাল ভেক্টর যাতে নমুনার বৈশিষ্ট্য রয়েছে i এবং y_i হল সেই ক্লাস যেটা x_i এর অন্তর্গত। যেখানে y_i লেবেলটি k মানগুলির একটিকে ধরে নিতে পারে, যেখানে k হল 2-এর চেয়ে বেশি শ্রেণির সংখ্যা। লক্ষ্য হল একটি মডেল তৈরি করা যা প্রতিটি ইনপুট নমুনার x_i লেবেল y_i-এর পূর্বাভাস দেয়।

বহু-শ্রেণীর শ্রেণীবিভাগ সমস্যা হিসাবে বিবেচিত কাজের উদাহরণ:

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

3 মাল্টি-ক্লাস শ্রেণীবিভাগের জন্য সক্রিয়করণ এবং ক্ষতি ফাংশন

মাল্টি-ক্লাস শ্রেণীবিভাগে আপনাকে দেওয়া হয়েছে:

• নমুনার একটি সেট {(x_1, y_1), (x_2, y_2),...,(x_n, y_n)}

• x_i হল একটি m-মাত্রিক ভেক্টর যা নমুনা i এর বৈশিষ্ট্য ধারণ করে

• y_i হল সেই ক্লাস যেখানে x_i অন্তর্গত এবং k মানগুলির একটি ধরে নিতে পারে, যেখানে k>2 হল ক্লাসের সংখ্যা।

  
  

একটি সম্ভাব্য ক্লাসিফায়ার হিসাবে একটি বহু-শ্রেণীর শ্রেণীবিভাগ নিউরাল নেটওয়ার্ক তৈরি করতে আমাদের প্রয়োজন:

• k এর আকার সহ একটি আউটপুট সম্পূর্ণভাবে সংযুক্ত স্তর
• আউটপুট মান পরিসীমা হতে হবে [0,1]
• আউটপুট মানের সমষ্টি 1 এর সমান হওয়া উচিত। বহু-শ্রেণীর শ্রেণীবিভাগে, প্রতিটি ইনপুট x শুধুমাত্র একটি শ্রেণীর (পারস্পরিক একচেটিয়া ক্লাস) এর অন্তর্গত হতে পারে, তাই সমস্ত শ্রেণীর সমষ্টি 1 হওয়া উচিত: SUM(p_0,…,p_k) )=1 ।
• একটি ক্ষতি ফাংশন যার সর্বনিম্ন মান থাকে যখন ভবিষ্যদ্বাণী এবং স্থল সত্য একই হয়

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

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

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

• k আউটপুট মান সীমার মধ্যে হওয়া উচিত (0,1), যেখানে k হল ক্লাসের সংখ্যা

• k আউটপুট মানের যোগফল 1 এর সমান হওয়া উচিত

  
  

  

  
  

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

  
  

আরেকটি উপায় হল ইনপুট মানের সূচকটি নেওয়া এবং এটিকে সমস্ত ইনপুট মানের সূচকের যোগফল দিয়ে ভাগ করা:

সফটম্যাক্স ফাংশন বাস্তব সংখ্যার একটি ভেক্টরকে সম্ভাব্যতার ভেক্টরে রূপান্তরিত করে। ফলাফলের প্রতিটি সম্ভাব্যতা পরিসরে (0,1), এবং সম্ভাব্যতার যোগফল 1।

সফ্টম্যাক্সের সাথে কাজ করার সময় আপনাকে একটি জিনিস সম্পর্কে সচেতন হতে হবে: আউটপুট মান p_i ইনপুট অ্যারের সমস্ত মানের উপর নির্ভর করে যেহেতু আমরা এটিকে সমস্ত মানের সূচকের যোগফল দিয়ে ভাগ করি। নীচের টেবিলটি এটি প্রদর্শন করে: দুটি ইনপুট ভেক্টরের 3টি সাধারণ মান রয়েছে {1, 3, 4}, কিন্তু আউটপুট সফ্টম্যাক্স মানগুলি পৃথক কারণ দ্বিতীয় উপাদানটি ভিন্ন (2 এবং 4)।

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

বাইনারি ক্রস এনট্রপি ক্ষতি সংজ্ঞায়িত করা হয় এইভাবে:

বাইনারি শ্রেণীবিভাগে, দুটি আউটপুট সম্ভাব্যতা p_i এবং (1-p_i) এবং স্থল সত্য মান y_i এবং (1-y_i) রয়েছে।

মাল্টি-ক্লাস শ্রেণীবিভাগ সমস্যা N ক্লাসের জন্য BCE ক্ষতির সাধারণীকরণ ব্যবহার করে: ক্রস-এনট্রপি ক্ষতি।

N হল ইনপুট নমুনার সংখ্যা, y_i হল গ্রাউন্ড ট্রুথ, এবং p_i হল i ক্লাসের পূর্বাভাসিত সম্ভাব্যতা।

PyTorch সহ 4 মাল্টি-ক্লাস শ্রেণীবিভাগ NN উদাহরণ

একটি সম্ভাব্য মাল্টি-ক্লাস শ্রেণীবিভাগ NN বাস্তবায়ন করতে আমাদের প্রয়োজন:

• গ্রাউন্ড ট্রুথ এবং ভবিষ্যদ্বাণীর মাত্রা থাকতে হবে [N,k] যেখানে N হল ইনপুট নমুনার সংখ্যা, k হল ক্লাসের সংখ্যা - ক্লাস আইডি কে সাইজ সহ একটি ভেক্টরে এনকোড করা দরকার
• চূড়ান্ত রৈখিক স্তরের আকার k হওয়া উচিত
• চূড়ান্ত স্তর থেকে আউটপুট আউটপুট সম্ভাব্যতা প্রাপ্ত করার জন্য softmax সক্রিয়করণের সাথে প্রক্রিয়া করা উচিত
• CE ক্ষতি পূর্বাভাসিত শ্রেণীর সম্ভাব্যতা এবং স্থল সত্য মান প্রয়োগ করা উচিত
• আকার k সহ আউটপুট ভেক্টর থেকে আউটপুট ক্লাস আইডি খুঁজুন

কোডের বেশিরভাগ অংশ বাইনারি শ্রেণীবিভাগের পূর্ববর্তী নিবন্ধের কোডের উপর ভিত্তি করে।

পরিবর্তিত অংশগুলি (পরিবর্তিত) দিয়ে চিহ্নিত করা হয়েছে:

• ডেটা প্রিপ্রসেসিং এবং পোস্টপ্রসেসিং
• সক্রিয়করণ ফাংশন
• ক্ষতি ফাংশন
• কর্মক্ষমতা মেট্রিক
• বিভ্রান্তি ম্যাট্রিক্স

PyTorch ফ্রেমওয়ার্কের সাথে মাল্টি-ক্লাস শ্রেণীবিভাগের জন্য একটি নিউরাল নেটওয়ার্ক কোড করি।

প্রথমত, ইনস্টল করুন টর্চমেট্রিক্স - এই প্যাকেজটি পরে শ্রেণীবিভাগের নির্ভুলতা এবং বিভ্রান্তি ম্যাট্রিক্স গণনা করতে ব্যবহার করা হবে।

 # used for accuracy metric and confusion matrix !pip install torchmetrics

কোডে পরে ব্যবহার করা হবে এমন প্যাকেজ আমদানি করুন

 from sklearn.datasets import make_classification import numpy as np import torch import torchmetrics import matplotlib.pyplot as plt import seaborn as sn import pandas as pd from sklearn.decomposition import PCA

4.1 ডেটাসেট তৈরি করুন

ক্লাসের সংখ্যা সহ গ্লোবাল ভেরিয়েবল সেট করুন (যদি আপনি এটি 2 এ সেট করেন এবং বাইনারি-শ্রেণিকরণ NN পান যা সফটম্যাক্স এবং ক্রস-এনট্রপি লস ব্যবহার করে)

 number_of_classes=4

আমি ব্যবহার করা হবে sklearn.datasets.make_classification একটি বাইনারি শ্রেণীবিভাগ ডেটাসেট তৈরি করতে:

• n_samples - উৎপন্ন নমুনার সংখ্যা

• n_features - উৎপন্ন নমুনা X এর মাত্রার সংখ্যা সেট করে

• n_classes - উৎপন্ন ডেটাসেটে ক্লাসের সংখ্যা। মাল্টি-ক্লাস শ্রেণীবিভাগের সমস্যায়, 2টির বেশি শ্রেণী থাকতে হবে

  
  

তৈরি করা ডেটাসেটে আকৃতি [n_samples, n_features] সহ X এবং আকৃতি [n_samples, ] সহ Y থাকবে।

 def get_dataset(n_samples=10000, n_features=20, n_classes=2): # https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html#sklearn.datasets.make_classification data_X, data_y = make_classification(n_samples=n_samples, n_features=n_features, n_classes=n_classes, n_informative=n_classes, n_redundant=0, n_clusters_per_class=2, random_state=42, class_sep=4) return data_X, data_y

4.2 ডেটাসেট ভিজ্যুয়ালাইজেশন

ডেটাসেট পরিসংখ্যান কল্পনা এবং মুদ্রণ করতে ফাংশন সংজ্ঞায়িত করুন। show_dataset ফাংশন ব্যবহার করে পিসিএ 2D প্লটে X ইনপুট ডেটার ভিজ্যুয়ালাইজেশনের সরলতার জন্য যেকোনো সংখ্যা থেকে X-এর মাত্রা কমিয়ে 2-এ নামিয়ে আনতে।

 def print_dataset(X, y): print(f'X shape: {X.shape}, min: {X.min()}, max: {X.max()}') print(f'y shape: {y.shape}') print(y[:10]) def show_dataset(X, y, title=''): if X.shape[1] > 2: X_pca = PCA(n_components=2).fit_transform(X) else: X_pca = X fig = plt.figure(figsize=(4, 4)) plt.scatter(x=X_pca[:, 0], y=X_pca[:, 1], c=y, alpha=0.5) # generate colors for all classes colors = plt.cm.rainbow(np.linspace(0, 1, number_of_classes)) # iterate over classes and visualize them with the dedicated color for class_id in range(number_of_classes): class_mask = np.argwhere(y == class_id) X_class = X_pca[class_mask[:, 0]] plt.scatter(x=X_class[:, 0], y=X_class[:, 1], c=np.full((X_class[:, 0].shape[0], 4), colors[class_id]), label=class_id, alpha=0.5) plt.title(title) plt.legend(loc="best", title="Classes") plt.xticks() plt.yticks() plt.show()

4.3 ডেটাসেট স্কেলার

ন্যূনতম সর্বোচ্চ স্কেলার সহ ডেটাসেট বৈশিষ্ট্যগুলি X থেকে পরিসরে [0,1] স্কেল করুন। এটি সাধারণত দ্রুত এবং আরো স্থিতিশীল প্রশিক্ষণের জন্য করা হয়।

 def scale(x_in): return (x_in - x_in.min(axis=0))/(x_in.max(axis=0)-x_in.min(axis=0))

আসুন জেনারেট করা ডেটাসেট পরিসংখ্যান প্রিন্ট আউট করি এবং উপরের ফাংশনগুলির সাথে এটিকে কল্পনা করি।

 X, y = get_dataset(n_classes=number_of_classes) print('before scaling') print_dataset(X, y) show_dataset(X, y, 'before') X_scaled = scale(X) print('after scaling') print_dataset(X_scaled, y) show_dataset(X_scaled, y, 'after')

আপনার যে আউটপুটগুলি পাওয়া উচিত তা নীচে রয়েছে।

 before scaling X shape: (10000, 20), min: -9.549551632357336, max: 9.727761741276673 y shape: (10000,) [0 2 1 2 0 2 0 1 1 2] 

 after scaling X shape: (10000, 20), min: 0.0, max: 1.0 y shape: (10000,) [0 2 1 2 0 2 0 1 1 2] 

সর্বনিম্ন-ম্যাক্স স্কেলিং ডেটাসেট বৈশিষ্ট্যগুলিকে বিকৃত করে না, এটি রৈখিকভাবে তাদের পরিসরে রূপান্তরিত করে [0,1]। "মিনিমাম-সর্বোচ্চ স্কেলিংয়ের পরে ডেটাসেট" চিত্রটি পূর্ববর্তী চিত্রের তুলনায় বিকৃত বলে মনে হচ্ছে কারণ PCA অ্যালগরিদম দ্বারা 20 মাত্রা কমিয়ে 2 করা হয়েছে এবং PCA অ্যালগরিদম সর্বনিম্ন-সর্বোচ্চ স্কেলিং দ্বারা প্রভাবিত হতে পারে।

PyTorch ডেটা লোডার তৈরি করুন। sklearn.datasets.make_classification দুটি নম্পি অ্যারে হিসাবে ডেটাসেট তৈরি করে। PyTorch ডেটালোডার তৈরি করতে আমাদের torch.utils.data.TensorDataset এর সাথে torch.tensor-এ numpy ডেটাসেট রূপান্তর করতে হবে।

 def get_data_loaders(dataset, batch_size=32, shuffle=True): data_X, data_y = dataset # https://pytorch.org/docs/stable/data.html#torch.utils.data.TensorDataset torch_dataset = torch.utils.data.TensorDataset(torch.tensor(data_X, dtype=torch.float32), torch.tensor(data_y, dtype=torch.float32)) # https://pytorch.org/docs/stable/data.html#torch.utils.data.random_split train_dataset, val_dataset = torch.utils.data.random_split(torch_dataset, [int(len(torch_dataset)*0.8), int(len(torch_dataset)*0.2)], torch.Generator().manual_seed(42)) # https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader loader_train = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle) loader_val = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle) return loader_train, loader_val

PyTorch ডেটা লোডার পরীক্ষা করুন

 dataloader_train, dataloader_val = get_data_loaders(get_dataset(n_classes=number_of_classes), batch_size=32) train_batch_0 = next(iter(dataloader_train)) print(f'Batches in the train dataloader: {len(dataloader_train)}, X: {train_batch_0[0].shape}, Y: {train_batch_0[1].shape}') val_batch_0 = next(iter(dataloader_val)) print(f'Batches in the validation dataloader: {len(dataloader_val)}, X: {val_batch_0[0].shape}, Y: {val_batch_0[1].shape}')

আউটপুট:

 Batches in the train dataloader: 250, X: torch.Size([32, 20]), Y: torch.Size([32]) Batches in the validation dataloader: 63, X: torch.Size([32, 20]), Y: torch.Size([32])

4.4 ডেটাসেট প্রি-প্রসেসিং এবং পোস্ট-প্রসেসিং (পরিবর্তিত)

প্রি এবং পোস্টপ্রসেসিং ফাংশন তৈরি করুন। বর্তমান Y আকৃতিটি [N] হওয়ার আগে আপনি হয়তো লক্ষ্য করেছেন, আমাদের এটি [N,number_of_classes] হতে হবে। এটি করার জন্য আমাদের ওয়ান-হট এনকোড করতে হবে Y ভেক্টরের মানগুলি।

ওয়ান-হট এনকোডিং হল ক্লাস ইনডেক্সকে একটি বাইনারি উপস্থাপনায় রূপান্তর করার একটি প্রক্রিয়া যেখানে প্রতিটি ক্লাস একটি অনন্য বাইনারি ভেক্টর দ্বারা প্রতিনিধিত্ব করা হয়।

অন্য কথায়: আকার [number_of_classes] সহ একটি শূন্য ভেক্টর তৈরি করুন এবং উপাদানটিকে class_id 1 এ সেট করুন, যেখানে class_ids {0,1,…,number_of_classes-1}:

0 >> [1. 0. 0. 0।]

1 >> [0. 1. 0. 0।]

2 >> [0. 0. 1. 0।]

2 >> [0. 0. 0. 1।]

Pytorch tensors torch.nn.functional.one_hot দিয়ে প্রসেস করা যেতে পারে এবং নম্পি ইমপ্লিমেন্টেশন খুবই সোজা। আউটপুট ভেক্টরের আকৃতি থাকবে [N,number_of_classes]।

 def preprocessing(y, n_classes): ''' one-hot encoding for input numpy array or pytorch Tensor input: y - [N,] numpy array or pytorch Tensor output: [N, n_classes] the same type as input ''' assert type(y)==np.ndarray or torch.is_tensor(y), f'input should be numpy array or torch tensor. Received input is: {type(categorical)}' assert len(y.shape)==1, f'input shape should be [N,]. Received input shape is: {y.shape}' if torch.is_tensor(y): return torch.nn.functional.one_hot(y, num_classes=n_classes) else: categorical = np.zeros([y.shape[0], n_classes]) categorical[np.arange(y.shape[0]), y]=1 return categorical

ওয়ান-হট এনকোডেড ভেক্টরকে আবার ক্লাস আইডিতে রূপান্তর করতে আমাদের ওয়ান-হট এনকোডেড ভেক্টরে সর্বাধিক উপাদানটির সূচক খুঁজে বের করতে হবে। এটি torch.argmax বা np.argmax একটি নীচে দিয়ে করা যেতে পারে।

 def postprocessing(categorical): ''' one-hot to classes decoding with .argmax() input: categorical - [N,classes] numpy array or pytorch Tensor output: [N,] the same type as input ''' assert type(categorical)==np.ndarray or torch.is_tensor(categorical), f'input should be numpy array or torch tensor. Received input is: {type(categorical)}' assert len(categorical.shape)==2, f'input shape should be [N,classes]. Received input shape is: {categorical.shape}' if torch.is_tensor(categorical): return torch.argmax(categorical,dim=1) else: return np.argmax(categorical, axis=1)

সংজ্ঞায়িত প্রাক এবং পোস্টপ্রসেসিং ফাংশন পরীক্ষা করুন।

 y = get_dataset(n_classes=number_of_classes)[1] y_logits = preprocessing(y, n_classes=number_of_classes) y_class = postprocessing(y_logits) print(f'y shape: {y.shape}, y preprocessed shape: {y_logits.shape}, y postprocessed shape: {y_class.shape}') print('Preprocessing does one-hot encoding of class ids.') print('Postprocessing does one-hot decoding of class one-hot encoded class ids.') for i in range(10): print(f'{y[i]} >> {y_logits[i]} >> {y_class[i]}')

আউটপুট:

 y shape: (10000,), y preprocessed shape: (10000, 4), y postprocessed shape: (10000,) Preprocessing does one-hot encoding of class ids. Postprocessing does one-hot decoding of one-hot encoded class ids. id>>one-hot encoding>>id 0 >> [1. 0. 0. 0.] >> 0 2 >> [0. 0. 1. 0.] >> 2 1 >> [0. 1. 0. 0.] >> 1 2 >> [0. 0. 1. 0.] >> 2 0 >> [1. 0. 0. 0.] >> 0 2 >> [0. 0. 1. 0.] >> 2 0 >> [1. 0. 0. 0.] >> 0 1 >> [0. 1. 0. 0.] >> 1 1 >> [0. 1. 0. 0.] >> 1 2 >> [0. 0. 1. 0.] >> 2

4.5 একটি বহু-শ্রেণীর শ্রেণীবিভাগ মডেল তৈরি এবং প্রশিক্ষণ

এই বিভাগটি একটি বাইনারি শ্রেণীবিভাগ মডেল প্রশিক্ষণের জন্য প্রয়োজনীয় সমস্ত ফাংশনের বাস্তবায়ন দেখায়।

4.5.1 Softmax সক্রিয়করণ (পরিবর্তিত)

softmax সূত্রের PyTorch-ভিত্তিক বাস্তবায়ন

 def softmax(x): assert len(x.shape)==2, f'input shape should be [N,classes]. Received input shape is: {x.shape}' # Subtract the maximum value for numerical stability # you can find explanation here: https://www.deeplearningbook.org/contents/numerical.html x = x - torch.max(x, dim=1, keepdim=True)[0] # Exponentiate the values exp_x = torch.exp(x) # Sum along the specified dimension sum_exp_x = torch.sum(exp_x, dim=1, keepdim=True) # Compute the softmax return exp_x / sum_exp_x

আসুন softmax পরীক্ষা করা যাক:

1. ধাপ 1 সহ [-10, 11] পরিসরে test_input numpy অ্যারে তৈরি করুন

2. আকৃতি সহ একটি টেনসরে এটিকে পুনরায় আকার দিন [7,3]

3. বাস্তবায়িত softmax ফাংশন এবং PyTorch ডিফল্ট বাস্তবায়ন torch.nn.functional.softmax সহ পরীক্ষা_ইনপুট প্রক্রিয়া করুন

4. ফলাফল তুলনা করুন (তাদের অভিন্ন হওয়া উচিত)

5. সাতটি [1,3] টেনসরের জন্য আউটপুট সফটম্যাক্স মান এবং যোগফল

   
   

 test_input = torch.arange(-10, 11, 1, dtype=torch.float32) test_input = test_input.reshape(-1,3) softmax_output = softmax(test_input) print(f'Input data shape: {test_input.shape}') print(f'input data range: [{test_input.min():.3f}, {test_input.max():.3f}]') print(f'softmax output data range: [{softmax_output.min():.3f}, {softmax_output.max():.3f}]') print(f'softmax output data sum along axis 1: [{softmax_output.sum(axis=1).numpy()}]') softmax_output_pytorch = torch.nn.functional.softmax(test_input, dim=1) print(f'softmax output is the same with pytorch implementation: {(softmax_output_pytorch==softmax_output).all().numpy()}') print('Softmax activation changes values in the chosen axis (1) so that they always sum up to 1:') for i in range(softmax_output.shape[0]): print(f'\t{i}. Sum before softmax: {test_input[i].sum().numpy()} | Sum after softmax: {softmax_output[i].sum().numpy()}') print(f'\t values before softmax: {test_input[i].numpy()}, softmax output values: {softmax_output[i].numpy()}')

আউটপুট:

 Input data shape: torch.Size([7, 3]) input data range: [-10.000, 10.000] softmax output data range: [0.090, 0.665] softmax output data sum along axis 1: [[1. 1. 1. 1. 1. 1. 1.]] softmax output is the same with pytorch implementation: True Softmax activation changes values in the chosen axis (1) so that they always sum up to 1: 0. Sum before softmax: -27.0 | Sum after softmax: 1.0 values before softmax: [-10. -9. -8.], softmax output values: [0.09003057 0.24472848 0.66524094] 1. Sum before softmax: -18.0 | Sum after softmax: 1.0 values before softmax: [-7. -6. -5.], softmax output values: [0.09003057 0.24472848 0.66524094] 2. Sum before softmax: -9.0 | Sum after softmax: 1.0 values before softmax: [-4. -3. -2.], softmax output values: [0.09003057 0.24472848 0.66524094] 3. Sum before softmax: 0.0 | Sum after softmax: 1.0 values before softmax: [-1. 0. 1.], softmax output values: [0.09003057 0.24472848 0.66524094] 4. Sum before softmax: 9.0 | Sum after softmax: 1.0 values before softmax: [2. 3. 4.], softmax output values: [0.09003057 0.24472848 0.66524094] 5. Sum before softmax: 18.0 | Sum after softmax: 1.0 values before softmax: [5. 6. 7.], softmax output values: [0.09003057 0.24472848 0.66524094] 6. Sum before softmax: 27.0 | Sum after softmax: 1.0 values before softmax: [ 8. 9. 10.], softmax output values: [0.09003057 0.24472848 0.66524094]

4.5.2 ক্ষতি ফাংশন: ক্রস-এনট্রপি (পরিবর্তিত)

সিই সূত্রের পাইটর্চ-ভিত্তিক বাস্তবায়ন

 def cross_entropy_loss(softmax_logits, labels): # Calculate the cross-entropy loss loss = -torch.sum(labels * torch.log(softmax_logits)) / softmax_logits.size(0) return loss

পরীক্ষা সিই বাস্তবায়ন:

1. আকৃতি [10,5] সহ test_input অ্যারে তৈরি করুন এবং পরিসরে [0,1) মান সহ torch.rand

2. আকৃতি [10,] এবং পরিসরে [0,4] মান সহ test_target অ্যারে তৈরি করুন।

3. এক-হট এনকোড test_target অ্যারে

4. বাস্তবায়িত cross_entropy ফাংশন এবং PyTorch বাস্তবায়নের সাথে গণনা ক্ষতি torch.nn.functional.binary_cross_entropy

5. ফলাফল তুলনা করুন (তাদের অভিন্ন হওয়া উচিত)

   
   

 test_input = torch.rand(10, 5, requires_grad=False) test_target = torch.randint(0, 5, (10,), requires_grad=False) test_target = preprocessing(test_target, n_classes=5).float() print(f'test_input shape: {list(test_input.shape)}, test_target shape: {list(test_target.shape)}') # get loss with the cross_entropy_loss implementation loss = cross_entropy_loss(softmax(test_input), test_target) # get loss with the torch.nn.functional.cross_entropy implementation # !!!torch.nn.functional.cross_entropy applies softmax on input logits # !!!pass it test_input without softmax activation loss_pytorch = torch.nn.functional.cross_entropy(test_input, test_target) print(f'Loss outputs are the same: {(loss==loss_pytorch).numpy()}')

প্রত্যাশিত আউটপুট:

 test_input shape: [10, 5], test_target shape: [10, 5] Loss outputs are the same: True

4.5.3 সঠিকতা মেট্রিক (পরিবর্তিত)

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

একটি বহু-শ্রেণীর শ্রেণিবিন্যাস নির্ভুলতা মেট্রিক তৈরি করতে দুটি পরামিতি প্রয়োজন:

• টাস্ক টাইপ "মাল্টিক্লাস"

• ক্লাস সংখ্যা num_classes

  
  

 # https://torchmetrics.readthedocs.io/en/stable/classification/accuracy.html#module-interface accuracy_metric=torchmetrics.classification.Accuracy(task="multiclass", num_classes=number_of_classes) def compute_accuracy(y_pred, y): assert len(y_pred.shape)==2 and y_pred.shape[1] == number_of_classes, 'y_pred shape should be [N, C]' assert len(y.shape)==2 and y.shape[1] == number_of_classes, 'y shape should be [N, C]' return accuracy_metric(postprocessing(y_pred), postprocessing(y))

4.5.4 NN মডেল

এই উদাহরণে ব্যবহৃত NN হল 2টি লুকানো স্তর সহ একটি গভীর NN। ইনপুট এবং লুকানো স্তরগুলি ReLU অ্যাক্টিভেশন ব্যবহার করে এবং চূড়ান্ত স্তরটি ক্লাস ইনপুট হিসাবে প্রদত্ত অ্যাক্টিভেশন ফাংশন ব্যবহার করে (এটি সিগমায়েড অ্যাক্টিভেশন ফাংশন হবে যা আগে প্রয়োগ করা হয়েছিল)।

 class ClassifierNN(torch.nn.Module): def __init__(self, loss_function, activation_function, input_dims=2, output_dims=1): super().__init__() self.linear1 = torch.nn.Linear(input_dims, input_dims * 4) self.linear2 = torch.nn.Linear(input_dims * 4, input_dims * 8) self.linear3 = torch.nn.Linear(input_dims * 8, input_dims * 4) self.output = torch.nn.Linear(input_dims * 4, output_dims) self.loss_function = loss_function self.activation_function = activation_function def forward(self, x): x = torch.nn.functional.relu(self.linear1(x)) x = torch.nn.functional.relu(self.linear2(x)) x = torch.nn.functional.relu(self.linear3(x)) x = self.activation_function(self.output(x)) return x

4.5.5 প্রশিক্ষণ, মূল্যায়ন এবং ভবিষ্যদ্বাণী

উপরের চিত্রটি একটি একক ব্যাচের প্রশিক্ষণের যুক্তিকে চিত্রিত করে। পরে ট্রেন_এপোচ ফাংশনটি একাধিকবার কল করা হবে (নির্বাচিত সংখ্যার সংখ্যা)।

 def train_epoch(model, optimizer, dataloader_train): # set the model to the training mode # https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.train model.train() losses = [] accuracies = [] for step, (X_batch, y_batch) in enumerate(dataloader_train): ### forward propagation # get model output and use loss function y_pred = model(X_batch) # get class probabilities with shape [N,1] # apply loss function on predicted probabilities and ground truth loss = model.loss_function(y_pred, y_batch) ### backward propagation # set gradients to zero before backpropagation # https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html optimizer.zero_grad() # compute gradients # https://pytorch.org/docs/stable/generated/torch.Tensor.backward.html loss.backward() # update weights # https://pytorch.org/docs/stable/optim.html#taking-an-optimization-step optimizer.step() # update model weights # calculate batch accuracy acc = compute_accuracy(y_pred, y_batch) # append batch loss and accuracy to corresponding lists for later use accuracies.append(acc) losses.append(float(loss.detach().numpy())) # compute average epoch accuracy train_acc = np.array(accuracies).mean() # compute average epoch loss loss_epoch = np.array(losses).mean() return train_acc, loss_epoch

মূল্যায়ন ফাংশন প্রদত্ত PyTorch ডেটালোডারের উপর পুনরাবৃত্তি করে বর্তমান মডেলের নির্ভুলতা গণনা করে এবং গড় ক্ষতি এবং গড় নির্ভুলতা প্রদান করে।

 def evaluate(model, dataloader_in): # set the model to the evaluation mode # https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.eval model.eval() val_acc_epoch = 0 losses = [] accuracies = [] # disable gradient calculation for evaluation # https://pytorch.org/docs/stable/generated/torch.no_grad.html with torch.no_grad(): for step, (X_batch, y_batch) in enumerate(dataloader_in): # get predictions y_pred = model(X_batch) # calculate loss loss = model.loss_function(y_pred, y_batch) # calculate batch accuracy acc = compute_accuracy(y_pred, y_batch) accuracies.append(acc) losses.append(float(loss.detach().numpy())) # compute average accuracy val_acc = np.array(accuracies).mean() # compute average loss loss_epoch = np.array(losses).mean() return val_acc, loss_epoch 

ভবিষ্যদ্বাণী ফাংশন প্রদত্ত ডেটালোডারের উপর পুনরাবৃত্তি করে, পোস্ট-প্রসেসড (এক-হট ডিকোডেড) মডেলের ভবিষ্যদ্বাণী এবং গ্রাউন্ড ট্রুথ মানগুলি [N,1] পাইটর্চ অ্যারেতে সংগ্রহ করে এবং উভয় অ্যারে ফেরত দেয়। পরে এই ফাংশনটি বিভ্রান্তি ম্যাট্রিক্স গণনা করতে এবং ভবিষ্যদ্বাণীগুলি কল্পনা করতে ব্যবহার করা হবে।

 def predict(model, dataloader): # set the model to the evaluation mode # https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.eval model.eval() xs, ys = next(iter(dataloader)) y_pred = torch.empty([0, ys.shape[1]]) x = torch.empty([0, xs.shape[1]]) y = torch.empty([0, ys.shape[1]]) # disable gradient calculation for evaluation # https://pytorch.org/docs/stable/generated/torch.no_grad.html with torch.no_grad(): for step, (X_batch, y_batch) in enumerate(dataloader): # get predictions y_batch_pred = model(X_batch) y_pred = torch.cat([y_pred, y_batch_pred]) y = torch.cat([y, y_batch]) x = torch.cat([x, X_batch]) # print(y_pred.shape, y.shape) y_pred = postprocessing(y_pred) y = postprocessing(y) return y_pred, y, x

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

 def model_train(model, optimizer, dataloader_train, dataloader_val, n_epochs=50): best_acc = 0 best_weights = None history = {'loss': {'train': [], 'validation': []}, 'accuracy': {'train': [], 'validation': []}} for epoch in range(n_epochs): # train on dataloader_train acc_train, loss_train = train_epoch(model, optimizer, dataloader_train) # evaluate on dataloader_val acc_val, loss_val = evaluate(model, dataloader_val) print(f'Epoch: {epoch} | Accuracy: {acc_train:.3f} / {acc_val:.3f} | ' + f'loss: {loss_train:.5f} / {loss_val:.5f}') # save epoch losses and accuracies in history dictionary history['loss']['train'].append(loss_train) history['loss']['validation'].append(loss_val) history['accuracy']['train'].append(acc_train) history['accuracy']['validation'].append(acc_val) # Save the best validation accuracy model if acc_val >= best_acc: print(f'\tBest weights updated. Old accuracy: {best_acc:.4f}. New accuracy: {acc_val:.4f}') best_acc = acc_val torch.save(model.state_dict(), 'best_weights.pt') # restore model and return best accuracy model.load_state_dict(torch.load('best_weights.pt')) return best_acc, history

4.5.6 ডেটাসেট পান, মডেল তৈরি করুন এবং প্রশিক্ষণ দিন (পরিবর্তিত)

আসুন সবকিছু একত্রিত করি এবং মাল্টি-ক্লাস ক্লাসিফিকেশন মডেলটি প্রশিক্ষণ দিই।

 ######################################### # Get the dataset X, y = get_dataset(n_classes=number_of_classes) print(f'Generated dataset shape. X:{X.shape}, y:{y.shape}') # change y numpy array shape from [N,] to [N, C] for multi-class classification y = preprocessing(y, n_classes=number_of_classes) print(f'Dataset shape prepared for multi-class classification with softmax activation and CE loss.') print(f'X:{X.shape}, y:{y.shape}') # Get train and validation datal loaders dataloader_train, dataloader_val = get_data_loaders(dataset=(scale(X), y), batch_size=32) # get a batch from dataloader and output intput and output shape X_0, y_0 = next(iter(dataloader_train)) print(f'Model input data shape: {X_0.shape}, output (ground truth) data shape: {y_0.shape}') ######################################### # Create ClassifierNN for multi-class classification problem # input dims: [N, features] # output dims: [N, C] where C is number of classes # activation - softmax to output [,C] probabilities so that their sum(p_1,p_2,...,p_c)=1 # loss - cross-entropy model = ClassifierNN(loss_function=cross_entropy_loss, activation_function=softmax, input_dims=X.shape[1], output_dims=y.shape[1]) ######################################### # create optimizer and train the model on the dataset optimizer = torch.optim.Adam(model.parameters(), lr=0.001) print(f'Model size: {sum([x.reshape(-1).shape[0] for x in model.parameters()])} parameters') print('#'*10) print('Start training') acc, history = model_train(model, optimizer, dataloader_train, dataloader_val, n_epochs=20) print('Finished training') print('#'*10) print("Model accuracy: %.2f%%" % (acc*100))

প্রত্যাশিত আউটপুট নীচে দেওয়া একটি অনুরূপ হওয়া উচিত.

 Generated dataset shape. X:(10000, 20), y:(10000,) Dataset shape prepared for multi-class classification with softmax activation and CE loss. X:(10000, 20), y:(10000, 4) Model input data shape: torch.Size([32, 20]), output (ground truth) data shape: torch.Size([32, 4]) Model size: 27844 parameters ########## Start training Epoch: 0 | Accuracy: 0.682 / 0.943 | loss: 0.78574 / 0.37459 Best weights updated. Old accuracy: 0.0000. New accuracy: 0.9435 Epoch: 1 | Accuracy: 0.960 / 0.967 | loss: 0.20272 / 0.17840 Best weights updated. Old accuracy: 0.9435. New accuracy: 0.9668 Epoch: 2 | Accuracy: 0.978 / 0.962 | loss: 0.12004 / 0.17931 Epoch: 3 | Accuracy: 0.984 / 0.979 | loss: 0.10028 / 0.13246 Best weights updated. Old accuracy: 0.9668. New accuracy: 0.9787 Epoch: 4 | Accuracy: 0.985 / 0.981 | loss: 0.08838 / 0.12720 Best weights updated. Old accuracy: 0.9787. New accuracy: 0.9807 Epoch: 5 | Accuracy: 0.986 / 0.981 | loss: 0.08096 / 0.12174 Best weights updated. Old accuracy: 0.9807. New accuracy: 0.9812 Epoch: 6 | Accuracy: 0.986 / 0.981 | loss: 0.07944 / 0.12036 Epoch: 7 | Accuracy: 0.988 / 0.982 | loss: 0.07605 / 0.11773 Best weights updated. Old accuracy: 0.9812. New accuracy: 0.9821 Epoch: 8 | Accuracy: 0.989 / 0.982 | loss: 0.07168 / 0.11514 Best weights updated. Old accuracy: 0.9821. New accuracy: 0.9821 Epoch: 9 | Accuracy: 0.989 / 0.983 | loss: 0.06890 / 0.11409 Best weights updated. Old accuracy: 0.9821. New accuracy: 0.9831 Epoch: 10 | Accuracy: 0.989 / 0.984 | loss: 0.06750 / 0.11128 Best weights updated. Old accuracy: 0.9831. New accuracy: 0.9841 Epoch: 11 | Accuracy: 0.990 / 0.982 | loss: 0.06505 / 0.11265 Epoch: 12 | Accuracy: 0.990 / 0.983 | loss: 0.06507 / 0.11272 Epoch: 13 | Accuracy: 0.991 / 0.985 | loss: 0.06209 / 0.11240 Best weights updated. Old accuracy: 0.9841. New accuracy: 0.9851 Epoch: 14 | Accuracy: 0.990 / 0.984 | loss: 0.06273 / 0.11157 Epoch: 15 | Accuracy: 0.991 / 0.984 | loss: 0.05998 / 0.11029 Epoch: 16 | Accuracy: 0.990 / 0.985 | loss: 0.06056 / 0.11164 Epoch: 17 | Accuracy: 0.991 / 0.984 | loss: 0.05981 / 0.11096 Epoch: 18 | Accuracy: 0.991 / 0.985 | loss: 0.05642 / 0.10975 Best weights updated. Old accuracy: 0.9851. New accuracy: 0.9851 Epoch: 19 | Accuracy: 0.990 / 0.986 | loss: 0.05929 / 0.10821 Best weights updated. Old accuracy: 0.9851. New accuracy: 0.9856 Finished training ########## Model accuracy: 98.56%

4.5.7 প্লট প্রশিক্ষণের ইতিহাস

 def plot_history(history): fig = plt.figure(figsize=(8, 4), facecolor=(0.0, 1.0, 0.0)) ax = fig.add_subplot(1, 2, 1) ax.plot(np.arange(0, len(history['loss']['train'])), history['loss']['train'], color='red', label='train') ax.plot(np.arange(0, len(history['loss']['validation'])), history['loss']['validation'], color='blue', label='validation') ax.set_title('Loss history') ax.set_facecolor((0.0, 1.0, 0.0)) ax.legend() ax = fig.add_subplot(1, 2, 2) ax.plot(np.arange(0, len(history['accuracy']['train'])), history['accuracy']['train'], color='red', label='train') ax.plot(np.arange(0, len(history['accuracy']['validation'])), history['accuracy']['validation'], color='blue', label='validation') ax.set_title('Accuracy history') ax.legend() fig.tight_layout() ax.set_facecolor((0.0, 1.0, 0.0)) fig.show() 

4.6 মডেলটি মূল্যায়ন করুন

4.6.1 ট্রেন এবং বৈধতা নির্ভুলতা গণনা করুন

 acc_train, _ = evaluate(model, dataloader_train) acc_validation, _ = evaluate(model, dataloader_val) print(f'Accuracy - Train: {acc_train:.4f} | Validation: {acc_validation:.4f}')

 Accuracy - Train: 0.9901 | Validation: 0.9851

4.6.2 প্রিন্ট কনফিউশন ম্যাট্রিক্স (পরিবর্তিত)

 val_preds, val_y, _ = predict(model, dataloader_val) print(val_preds.shape, val_y.shape) multiclass_confusion_matrix = torchmetrics.classification.ConfusionMatrix('multiclass', num_classes=number_of_classes) cm = multiclass_confusion_matrix(val_preds, val_y) print(cm) df_cm = pd.DataFrame(cm) plt.figure(figsize = (6,5), facecolor=(0.0,1.0,0.0)) sn.heatmap(df_cm, annot=True, fmt='d') plt.show() 

4.6.3 প্লট ভবিষ্যদ্বাণী এবং স্থল সত্য

 val_preds, val_y, val_x = predict(model, dataloader_val) val_preds, val_y, val_x = val_preds.numpy(), val_y.numpy(), val_x.numpy() show_dataset(val_x, val_y,'Ground Truth') show_dataset(val_x, val_preds, 'Predictions') 

উপসংহার

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