Naive Bayes — বাংলা SMS-কে spam না ham বলা

মডিউল ৯-এ আমরা অনিশ্চয়তার সঙ্গে যুক্তি করছি। পর্ব ৩৫-এ conditional probability আর Bayes-এর নিয়মের প্রথম পরিচয় পেয়েছেন, আর পর্ব ৫০ (Bayes-এর উপপাদ্য — প্রমাণ পেলে বিশ্বাস হালনাগাদ)-এ prior, likelihood আর posterior বিস্তারিত। এবার সেই নিয়মে অনেক শব্দের প্রমাণ মিলিয়ে একটি বার্তার শ্রেণি বলব। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, pandas 3.0.2, scikit-learn 1.8.0). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · কাজটি — বাজারঘরের গ্রাহকের SMS, আর আমাদের ৬০টি বার্তা

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) তার গ্রাহকদের SMS পাঠায়: অর্ডার নিশ্চিত, রাইডার পথে, টাকা ফেরত, লগইন কোড। একই ফোনে আসে প্রতারকদের বার্তাও: “আপনি লটারিতে ৫০০০০ টাকা জিতেছেন”, “আপনার অ্যাকাউন্ট আজ রাতে বন্ধ হবে, OTP পাঠান”, “৯৯ টাকায় স্মার্টফোন”. গ্রাহকসেবা দল চায় বাজারঘরের অ্যাপে একটি সতর্কবার্তা দেখাতে: “এই SMS সন্দেহজনক মনে হচ্ছে”. এর জন্য একটি binary classification লাগবে: প্রতিটি SMS-এর label হয় spam, নয় ham. “Ham” শব্দটি spam-এর উল্টো বোঝাতে ইমেইল ফিল্টারের জগতে চালু হয়েছিল; মানে সাধারণ, চাওয়া বার্তা।

সত্যিকারের গ্রাহকের SMS আমরা ব্যবহার করব না; তাতে গোপনীয়তার সমস্যা আছে। তাই নিচের ৬০টি বার্তা এই পর্বের জন্য বানানো: ২৫টি spam, ৩৫টি ham. Spam-এ আছে ভুয়া পুরস্কার ও লটারি, OTP চাওয়া বা “অ্যাকাউন্ট বন্ধ হবে” ধরনের ভয় দেখানো, অবিশ্বাস্য ছাড়, ভুয়া পার্সেল-ফি আর ঘরে বসে আয়ের প্রলোভন। Ham-এর ১৬টি বাজারঘরের আসল ধাঁচের অর্ডার ও ডেলিভারি বার্তা, ১৯টি ব্যক্তিগত বার্তা। ৩২টি শুধু বাংলা হরফে, ২০টি ইংরেজি বা Banglish-এ (রোমান হরফে বাংলা), ৮টিতে দুই হরফ মেশানো। সব ফোন নম্বর 01X00-000000 আর সব লিংক example.com-এর, কোনো আসল ব্র্যান্ড, ব্যাংক বা মোবাইল অপারেটরের নাম নেই।

ইচ্ছা করে কিছু কঠিন উদাহরণ রাখা হয়েছে: বাজারঘরের নিজের ১০% ছাড়ের বার্তা (ham, অথচ “ছাড়” শব্দটি spam-এ বেশি), লগইন কোডের বার্তা (ham, অথচ “কোড” আছে), ক্রিকেট ম্যাচে “জিতেছি” (ham). ফাইলটি পাতার ভেতরে sms.csv নামে রাখা, কোড একে নাম দিয়ে পড়ে।

পুরো ফাইল যেকোনো ব্লকে pd.read_csv("sms.csv") দিয়ে পড়ে দেখতে পারেন।

২ · বাংলা লেখাকে token-এ ভাঙা — NFC, অঙ্ক আর যতিচিহ্ন

Model লেখা পড়ে না, সংখ্যা পড়ে। প্রথম কাজ তাই একটি SMS-কে ছোট ছোট টুকরোয় ভাঙা, যাকে বলে tokenization; প্রতিটি টুকরো একটি token. ইংরেজিতে ফাঁকা জায়গায় ভাঙলেই অনেকটা কাজ হয়। বাংলায় চারটি বাড়তি সাবধানতা লাগে।

1. একই অক্ষরের দুই রূপ: “য়”, “ড়”, “ঢ়” এক code point-এও লেখা যায় (যেমন U+09DF), দুইটিতেও (য + নুক্তা ়)। চোখে এক, কিন্তু Python-এর কাছে দুটি আলাদা string, তাই “টাকায়” দুটি আলাদা শব্দ হয়ে যেতে পারে। Unicode normalization-এর NFC রূপে আনলে দুটি মেলে; পূর্ণ ব্যাখ্যা পর্ব ১০-এ, আর pandas-এ str.normalize("NFC") পর্ব ২৩-এ।
2. বড়-ছোট হাতের অক্ষর: “FREE” আর “free” একই শব্দ ধরতে lower(). বাংলায় এর কোনো প্রভাব নেই।
3. বাংলা আর ইংরেজি অঙ্ক: বাংলা keyboard-এ “৫০০” আসে, ইংরেজিতে “500”. দুটিকে এক token বানাতে str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789") দিয়ে বাংলা অঙ্ক ইংরেজিতে বদলাই।
4. যতিচিহ্ন: দাঁড়ি “।”, “!”, “:”, “%”, “#”, লিংকের “.” আর “-” সব token-এর সীমা। 01X00-000000 ভেঙে হবে 01x00 আর 000000; mega-deal.example.com ভেঙে চারটি token.

নিয়মটি একটি ছোট regular expression-এ লেখা যায়: [\s.,!?;:।#%()"'/\-]+, অর্থাৎ ফাঁকা জায়গা (\s) বা এই চিহ্নগুলোর যেকোনো ধারাবাহিকতায় কাটা হবে। Python-এ regex-এর বিস্তারিত দেখুন Python কোর্সের regular expression পর্বে। একটি প্রশ্ন বাকি: “শব্দের অক্ষর” খুঁজে খুঁজে token নিলে কী হয়? scikit-learn-এর default নিয়ম ঠিক তাই করে, (?u)\b\w\w+\b: দুই বা তার বেশি “word character”. সমস্যা হলো Python-এর \w বাংলার কার-চিহ্ন (vowel sign, যেমন া ি ু ে) আর হসন্ত (্)-কে word character মানে না, কারণ Unicode-এ এগুলো অক্ষর নয়, combining mark. নিচের stepper একটি নতুন কাল্পনিক SMS দিয়ে ধাপগুলো দেখায়; শেষ ধাপের ফল ডেস্কটপে scikit-learn 1.8.0-এর একটি সত্যিকারের run থেকে।

এই পর্বের সব কোড তাই নিজের tokenize() ব্যবহার করে। তবু আমাদের সরল ভাঙারও সীমা আছে, আর তা সৎভাবে মানা দরকার। বাংলা শব্দের শেষে বিভক্তি আর প্রত্যয় জোড়া লাগে: “টাকা”, “টাকায়”, “টাকার” আমাদের ৬০টি SMS-এ তিনটি আলাদা token (১২, ৩ আর ১ বার)। একইভাবে “জিতেছেন” আর “জিতেছি”, “লিংক” আর “লিংকে” আলাদা। ফলে model-কে একই অর্থের শব্দ তিনবার আলাদাভাবে শিখতে হয়, আর ছোট ডেটায় প্রতিটির গোনা কমে যায়। শব্দের মূল রূপ খুঁজে বের করাকে বলে stemming; বাংলার জন্য stemming আর আরও ভালো tokenizer পর্ব ৬৭ (বাংলা লেখার ডেটা — tokenization, TF-IDF আর একটি classifier)-এ আসবে। এই পর্বে আমরা অন্য একটি পথও দেখব: পুরো শব্দের বদলে অক্ষরের ছোট টুকরো (অংশ ৭)।

৩ · Bag of words — শব্দের থলি

Token পাওয়ার পর সবচেয়ে সরল প্রতিনিধিত্ব হলো bag of words: প্রতিটি SMS-কে একটি থলি ভাবুন, যার ভেতরে শব্দগুলো ঢেলে দেওয়া হয়েছে। ক্রম হারিয়ে যায়, থাকে শুধু “কোন শব্দ কতবার”. Training-এর সব বার্তায় দেখা আলাদা শব্দের তালিকাকে বলে vocabulary; আমাদের ৬০টি SMS-এ ৪২০টি আলাদা token, মোট ৭২২টি token. প্রতিটি SMS তখন ৪২০ ঘরের একটি feature vector, যার প্রায় সব ঘর ০, কারণ একটি SMS-এ গড়ে ১২টির মতো token থাকে।

এত শূন্য জমিয়ে রাখা অপচয়, তাই scikit-learn এমন টেবিল রাখে sparse matrix-এ: শুধু শূন্য নয় এমন ঘরের অবস্থান আর মান। এই গোনাটি গুরুত্বপূর্ণ কি না, নাকি শুধু “আছে কি নেই” জানলেই চলে, সেই প্রশ্ন থেকেই multinomial আর Bernoulli Naive Bayes-এর পার্থক্য (অংশ ৭)।

দুর্বলতা স্পষ্ট: ক্রম হারায়, তাই “বলবেন না”-র “না” কোন শব্দের সঙ্গে, তা জানা যায় না। শব্দের জোড়া feature হিসেবে নিলে কিছুটা ক্রম ফেরে; এই ধারণার নাম n-gram.

৪ · Naive Bayes-এর সূত্র — আর “naive” অনুমান কেন তবু কাজ করে

প্রশ্নটি Bayes-এর ভাষায়: SMS-এর শব্দগুলো w₁, w₂, …, w_n দেখা গেছে; শ্রেণি c (spam বা ham) হওয়ার সম্ভাবনা কত? Bayes-এর নিয়ম বলে:

P(c | w₁, …, w_n) = P(c) · P(w₁, …, w_n | c) / P(w₁, …, w_n)

এখানে P(c) হলো prior, অর্থাৎ কোনো শব্দ দেখার আগে spam-এর ভাগ; P(w₁, …, w_n | c) হলো likelihood, অর্থাৎ শ্রেণি c হলে ঠিক এই শব্দগুলো আসার সম্ভাবনা; বাঁ পাশেরটি posterior. হরটি দুই শ্রেণির জন্য একই, তাই কোন শ্রেণি বড় তা ঠিক করতে হরটি লাগে না; “∝” (সমানুপাতিক) দিয়ে লিখি।

মুশকিল হলো মাঝের likelihood. ১২টি শব্দের ঠিক এই সমাহার training-এ হয়তো একবারও আসেনি, তাই সরাসরি গোনা অসম্ভব। Naive Bayes এখানে একটি সাহসী সরলীকরণ করে: শ্রেণি জানা থাকলে প্রতিটি শব্দ অন্য শব্দগুলো থেকে স্বাধীন। এটিই conditional independence (পর্ব ৩৫-এ পরিচয়)। তখন যৌথ likelihood ভেঙে এক শব্দের likelihood-এর গুণফল হয়:

P(c | শব্দগুলো) ∝ P(c) × P(w₁ | c) × P(w₂ | c) × … × P(w_n | c) = P(c) · ∏_i P(w_i | c)

∏ মানে সব i-এর ওপর গুণ। প্রতিটি P(w | c) সহজে গোনা যায়: spam-এর সব token-এর মধ্যে “ফ্রি” কত ভাগ। এই সংখ্যাগুলো অনুমান করাই training; শিক্ষার আর কোনো ধাপ নেই। যে শ্রেণির score বড়, সেটিই উত্তর।

ছবিটি একটি generative model-এর গল্পও বলে: আগে একটি শ্রেণি বেছে নেওয়া হয় (P(c) অনুযায়ী), তারপর সেই শ্রেণির শব্দ-বণ্টন থেকে একটি একটি করে শব্দ তোলা হয়, যেন একটি থলি থেকে লটারির কাগজ। এই গল্প স্পষ্টতই সত্য নয়। বাস্তবের spam-এ “অভিনন্দন” এলে “জিতেছেন” আসার সম্ভাবনা অনেক বেশি; “লিংকে” আর “ক্লিক” প্রায় সবসময় একসঙ্গে আসে। Naive Bayes এগুলোকে স্বাধীন প্রমাণ ধরে দুবার গোনে, তাই তার দেওয়া সম্ভাবনা প্রায়ই অতিরিক্ত চরম হয়: ০.৯৯৯ বা ০.০০১.

তবু কাজ করে কেন?

১৯৯৭ সালে Pedro Domingos আর Michael Pazzani Machine Learning জার্নালে দেখান যে শ্রেণি বাছাইয়ের জন্য (zero-one loss, অর্থাৎ শুধু ঠিক বা ভুল গোনা) সম্ভাবনাগুলো নির্ভুল হওয়ার দরকার নেই; শুধু ঠিক শ্রেণিটি সবচেয়ে বড় score পেলেই হলো। দুবার গোনা প্রমাণ সাধারণত সঠিক শ্রেণির দিকেই ঠেলে, তাই score অতিরঞ্জিত হলেও ক্রম প্রায়ই ঠিক থাকে; তবে সম্ভাবনার মান নিজে ভরসাযোগ্য নয়, তাকে calibration দিয়ে যাচাই করতে হয় (ভাবনার প্রশ্ন ১)। তাই Naive Bayes প্রায়ই একটি দ্রুত, শক্ত baseline, শেষ কথা নয়।

৫ · হাতে হিসাব — ৬টি SMS, শূন্যের সমস্যা আর Laplace smoothing

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

নতুন SMS: “আজ ফ্রি ডেলিভারি অফার”. এটি বাজারঘরের আসল অফারও হতে পারে, spam-ও হতে পারে। ধাপগুলো: (১) prior: P(spam) = P(ham) = ৩/৬ = ০.৫. (২) গোনা: spam-এ মোট ১০টি token, ham-এ ৯টি; সব মিলিয়ে আলাদা শব্দ V = ১৪. (৩) প্রতিটি নতুন শব্দের likelihood, P(w | c) = গোনা ÷ শ্রেণির মোট token, যা আসলে maximum likelihood অনুমান। (৪) গুণ করে তুলনা।

এখানেই একটি ফাঁদ। “আজ” spam-এ একবারও আসেনি, তাই P(আজ | spam) = ০/১০ = ০. গুণফলে একটি শূন্য থাকলে পুরো গুণফল শূন্য, অন্য শব্দ যতই spam-এর দিকে ইঙ্গিত দিক। একে বলে zero-frequency problem. আর ham-এ “ফ্রি” আর “অফার” নেই, তাই ham-এর score-ও শূন্য। Model কোনো সিদ্ধান্তই নিতে পারে না। সমাধান Laplace smoothing: প্রতিটি শব্দের গোনায় ১ যোগ, আর হরে V যোগ (যাতে সম্ভাবনার যোগফল ১ থাকে):

P(w | c) = (count(w, c) + α) / (N_c + α · V)

N_c হলো শ্রেণি c-এর মোট token, V হলো vocabulary-র আকার, আর α = ১ হলে Laplace বা add-one. α যেকোনো ধনাত্মক সংখ্যা হলে নাম additive (add-α) smoothing, যাকে প্রায়ই Lidstone smoothing বলা হয়। ছোট α মানে দেখা গোনার ওপর বেশি ভরসা।

নিচের ব্লক একই হিসাব α = ০, ১ আর ০.১ দিয়ে করে। শুধু Python-এর standard library, তাই দ্রুত চলে।

from collections import Counter
import math

# ৬টি কাল্পনিক SMS: হাতে হিসাব মেলানোর জন্য
train = [("spam", "ফ্রি পুরস্কার জিতুন"), ("spam", "ফ্রি অফার লিংকে ক্লিক"),
         ("spam", "পুরস্কার পেতে ক্লিক"), ("ham", "অর্ডার পাঠানো হয়েছে"),
         ("ham", "অর্ডার আজ ডেলিভারি"), ("ham", "আজ বাসায় দাওয়াত")]
counts = {"spam": Counter(), "ham": Counter()}
for y, text in train:
    counts[y].update(text.split())
vocab = sorted(set(counts["spam"]) | set(counts["ham"]))
V = len(vocab)
print("V =", V, "| spam-এ token:", counts["spam"].total(), "| ham-এ token:", counts["ham"].total())

new = "আজ ফ্রি ডেলিভারি অফার".split()
for alpha in (0, 1, 0.1):
    print(f"\nalpha = {alpha}")
    score = {}
    for c in ("spam", "ham"):
        prior = sum(y == c for y, _ in train) / len(train)
        N = counts[c].total()
        lik = [(counts[c][w] + alpha) / (N + alpha * V) for w in new]
        score[c] = prior * math.prod(lik)
        print(c, "prior", prior, "|", " ".join(f"{w}:{p:.4f}" for w, p in zip(new, lik)),
              f"| score {score[c]:.3e}")
    total = sum(score.values())
    if total == 0:
        print("দুই শ্রেণির score-ই 0: সিদ্ধান্ত নেওয়া যায় না")
    else:
        print("P(ham | SMS) =", round(score["ham"] / total, 3), "→", max(score, key=score.get))

V = 14 | spam-এ token: 10 | ham-এ token: 9

alpha = 0
spam prior 0.5 | আজ:0.0000 ফ্রি:0.2000 ডেলিভারি:0.0000 অফার:0.1000 | score 0.000e+00
ham prior 0.5 | আজ:0.2222 ফ্রি:0.0000 ডেলিভারি:0.1111 অফার:0.0000 | score 0.000e+00
দুই শ্রেণির score-ই 0: সিদ্ধান্ত নেওয়া যায় না

alpha = 1
spam prior 0.5 | আজ:0.0417 ফ্রি:0.1250 ডেলিভারি:0.0417 অফার:0.0833 | score 9.042e-06
ham prior 0.5 | আজ:0.1304 ফ্রি:0.0435 ডেলিভারি:0.0870 অফার:0.0435 | score 1.072e-05
P(ham | SMS) = 0.542 → ham

alpha = 0.1
spam prior 0.5 | আজ:0.0088 ফ্রি:0.1842 ডেলিভারি:0.0088 অফার:0.0965 | score 6.839e-07
ham prior 0.5 | আজ:0.2019 ফ্রি:0.0096 ডেলিভারি:0.1058 অফার:0.0096 | score 9.873e-07
P(ham | SMS) = 0.591 → ham

৬ · Log probability — গুণ নয়, যোগ; আর নিজের হাতে পুরো classifier

খেলনা SMS-এ মাত্র চারটি শব্দ, তবু score নেমে গেছে 10⁻⁵-এ। প্রতিটি শব্দের সম্ভাবনা ১-এর অনেক কম, তাই ৩০০ শব্দের একটি লম্বা বার্তায় গুণফল হতে পারে 10⁻⁷⁰⁰-এর মতো। কিন্তু float64 মোটামুটি 10⁻³⁰⁸-এর চেয়ে ছোট সাধারণ মান রাখতে পারে না (subnormal ধরলেও প্রায় 10⁻³²⁴), তাই ফল চুপচাপ 0.0 হয়ে যায়: underflow, যা পর্ব ৩৫-এ জন্মদিনের সমস্যায় দেখেছেন। দুই শ্রেণিরই score 0.0 হলে তুলনা অর্থহীন।

সমাধান হলো log নেওয়া। log গুণকে যোগ বানায়, আর log একটি বর্ধমান function, তাই যে শ্রেণির গুণফল বড়, তার log-এর যোগফলও বড়:

score(c) = log P(c) + ∑_i log P(w_i | c)

প্রতিটি পদ একটি ঋণাত্মক সংখ্যা, আর যোগফল −১৬০০ হলেও float সহজে রাখতে পারে। এটিই log probability-র কৌশল; পর্ব ৩৮-এ log loss-এও একই কারণে log ছিল। দুই শ্রেণির score-এর পার্থক্য, score(spam) − score(ham), হলো log-odds: ধনাত্মক হলে spam, ঋণাত্মক হলে ham, আর মান যত বড় তত দৃঢ় সিদ্ধান্ত। সম্ভাবনা ফিরে পেতে চাইলে P(ham) = 1 / (1 + e^{−(score(ham) − score(spam))}).

৬০টি SMS-এ নিজের হাতে লেখা Naive Bayes

এবার পুরো ডেটা। আগে ডেটা ভাগ: ৭৫% train, ২৫% test. stratify দিলে দুই ভাগে spam আর ham-এর অনুপাত মূল ডেটার মতো থাকে (stratified ভাগ), আর random_state=42 দিলে প্রতিবার একই ভাগ (seed). Test-এর বার্তা vocabulary-তেও ঢোকে না; কেন, তা পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ। Test-এ যে শব্দ training-এ নেই, তাকে আমরা বাদ দিই; scikit-learn-ও তাই করে। শেষ চার লাইন ৩৫টি ham জোড়া দিয়ে একটি লম্বা বার্তা বানিয়ে underflow দেখায়। এই ব্লক আর পরের দুটি একই namespace ভাগ করে (data-shared); পরের কোনো ব্লক আগে চালালে এটি আপনা থেকে আগে চলে।

import re, math, unicodedata
from collections import Counter
import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("sms.csv")
SPLIT = re.compile(r"[\s.,!?;:।#%()\"'/\-]+")      # ফাঁকা জায়গা আর যতিচিহ্ন
BN2EN = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
def clean(t): return unicodedata.normalize("NFC", t).lower().translate(BN2EN)
def tokenize(t): return [w for w in SPLIT.split(clean(t)) if w]

tr, te = train_test_split(df, test_size=0.25, stratify=df["label"], random_state=42)
counts = {"ham": Counter(), "spam": Counter()}
for t, y in zip(tr["text"], tr["label"]):
    counts[y].update(tokenize(t))
vocab = set(counts["ham"]) | set(counts["spam"])
logprior = {c: math.log((tr["label"] == c).mean()) for c in counts}
def loglik(w, c, a=1.0):
    return math.log((counts[c][w] + a) / (counts[c].total() + a * len(vocab)))
def score(text):
    toks = [w for w in tokenize(text) if w in vocab]   # অচেনা শব্দ বাদ
    return {c: logprior[c] + sum(loglik(w, c) for w in toks) for c in counts}

pred = [max(s := score(t), key=s.get) for t in te["text"]]
print("train:", len(tr), "test:", len(te), te["label"].value_counts().to_dict())
print("vocab:", len(vocab), "| token:", {c: counts[c].total() for c in counts})
print("accuracy:", round(sum(p == y for p, y in zip(pred, te["label"])) / len(te), 3))

long_msg = " ".join(df.loc[df["label"] == "ham", "text"])   # ৩৫টি ham জোড়া
toks = [w for w in tokenize(long_msg) if w in vocab]
raw = {c: math.exp(logprior[c]) * math.prod(math.exp(loglik(w, c)) for w in toks)
       for c in counts}
print(len(toks), "টি token, সরাসরি গুণ:", raw)
print("log-এ যোগ:", {c: round(v, 1) for c, v in score(long_msg).items()})

train: 45 test: 15 {'ham': 9, 'spam': 6}
vocab: 340 | token: {'ham': 270, 'spam': 274}
accuracy: 0.8
309 টি token, সরাসরি গুণ: {'ham': 0.0, 'spam': 0.0}
log-এ যোগ: {'ham': -1665.1, 'spam': -1879.7}

৭ · scikit-learn দিয়ে যাচাই — Multinomial, Bernoulli আর char n-gram

নিজের লেখা কোড ঠিক কি না, তা জানার সবচেয়ে ভালো উপায় একটি পরীক্ষিত library-র সঙ্গে মেলানো। scikit-learn-এ দুটি অংশ লাগে: CountVectorizer লেখাকে bag-of-words-এর sparse matrix বানায়, আর MultinomialNB সেই গোনা থেকে শেখে। আমাদের tokenize সরাসরি analyzer হিসেবে দেওয়া যায়; তখন vectorizer নিজে কোনো preprocessing বা lowercase করে না, পুরো দায়িত্ব আমাদের function-এর। MultinomialNB(alpha=1.0)-এর সূত্র হুবহু অংশ ৫-এর (N_cw + α) / (N_c + αV), সঙ্গে training-এর শ্রেণি-অনুপাত prior হিসেবে।

দুই রকম Naive Bayes

সংজ্ঞা দুটি: multinomial Naive Bayes আর Bernoulli Naive Bayes. সংখ্যার feature-এর জন্য তৃতীয় ধরন GaussianNB, যা পর্ব ৪-এ ডেলিভারির দূরত্ব আর ওজন দিয়ে দেখেছেন; শব্দের গোনায় সেটি মানায় না।

শব্দের বদলে অক্ষরের টুকরো

অংশ ২-এর বিভক্তির সমস্যা এড়ানোর একটি সহজ পথ: শব্দকে পুরো না নিয়ে তার ভেতরের ২ থেকে ৪ অক্ষরের টুকরো নেওয়া, যাকে বলে character n-gram. analyzer="char_wb" শুধু শব্দের ভেতরে টুকরো বানায়, শব্দের দুই প্রান্তে একটি ফাঁকা জায়গা জুড়ে। তখন “টাকা”, “টাকায়” আর “টাকার” অনেক টুকরো (“টা”, “টাকা” ইত্যাদি) ভাগ করে নেয়, আর একটি নতুন বিভক্তিও পুরো অচেনা হয় না। দাম: feature অনেক বেশি। এখানে “অক্ষর” মানে code point, চোখে দেখা একক (grapheme cluster) নয়, তবে গোনার কাজে তাতে সমস্যা কম। preprocessor=clean দিয়ে আমাদের পরিষ্কারের নিয়ম এখানেও খাটে।

import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB, BernoulliNB
from sklearn.metrics import confusion_matrix

# scikit-learn-এর default token_pattern বাংলায় কী করে?
print(CountVectorizer().fit(["আপনার অর্ডার পাঠানো হয়েছে"]).get_feature_names_out())

vec = CountVectorizer(analyzer=tokenize)          # নিজের tokenizer
Xtr, Xte = vec.fit_transform(tr["text"]), vec.transform(te["text"])
mnb = MultinomialNB(alpha=1.0).fit(Xtr, tr["label"])
j = vec.vocabulary_["ফ্রি"]
print("vocab:", len(vec.vocabulary_), "| নিজের NB-এর সঙ্গে prediction মিল:",
      list(mnb.predict(Xte)) == pred, "| ফ্রি-র log P মিল:",
      bool(np.isclose(mnb.feature_log_prob_[1, j], loglik("ফ্রি", "spam"))))

cw = CountVectorizer(analyzer="char_wb", ngram_range=(2, 4), preprocessor=clean)
dv = CountVectorizer()
setups = {
    "Multinomial, শব্দ      ": (MultinomialNB(), vec),
    "Bernoulli, শব্দ        ": (BernoulliNB(), vec),
    "Multinomial, char_wb   ": (MultinomialNB(), cw),
    "Multinomial, default   ": (MultinomialNB(), dv),
}
y_true = te["label"].to_numpy()
for name, (model, v) in setups.items():
    A, B = v.fit_transform(tr["text"]), v.transform(te["text"])
    yp = model.fit(A, tr["label"]).predict(B)
    cm = confusion_matrix(y_true, yp, labels=["ham", "spam"])
    print(f"{name} features {A.shape[1]:>4}  accuracy {np.mean(yp == y_true):.3f}  "
          f"[[TN, FP], [FN, TP]] = {cm.tolist()}")

['অর' 'আপন' 'হয']
vocab: 340 | নিজের NB-এর সঙ্গে prediction মিল: True | ফ্রি-র log P মিল: True
Multinomial, শব্দ       features  340  accuracy 0.800  [[TN, FP], [FN, TP]] = [[6, 3], [0, 6]]
Bernoulli, শব্দ         features  340  accuracy 0.933  [[TN, FP], [FN, TP]] = [[9, 0], [1, 5]]
Multinomial, char_wb    features 3160  accuracy 0.867  [[TN, FP], [FN, TP]] = [[8, 1], [1, 5]]
Multinomial, default    features  227  accuracy 0.867  [[TN, FP], [FN, TP]] = [[7, 2], [0, 6]]

ছোট test set-এর ফাঁদ: leave-one-out

একটি ভাগের ফল ভাগ্যের ওপর অনেকটা নির্ভর করে। আরও স্থির মাপ পেতে ডেস্কটপে leave-one-out চালানো হয়েছে: ৬০ বার, প্রতিবার একটি SMS বাদ রেখে বাকি ৫৯টিতে পুরো pipeline (vectorizer সহ) নতুন করে train, তারপর বাদ রাখা SMS-টির উত্তর। তাতে প্রতিটি বার্তা একবার করে test-এ যায়। কোডের মূল অংশ (বাকিটা ওপরের ব্লকের মতো):

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import LeaveOneOut, cross_val_predict

setups = {
    "Multinomial, words, alpha=1  ": make_pipeline(words(), MultinomialNB(alpha=1.0)),
    "Multinomial, words, alpha=0.1": make_pipeline(words(), MultinomialNB(alpha=0.1)),
    "Bernoulli, words, alpha=1    ": make_pipeline(words(), BernoulliNB(alpha=1.0)),
    "Multinomial, char_wb 2-4     ": make_pipeline(chars(), MultinomialNB(alpha=1.0)),
    "Multinomial, default pattern ": make_pipeline(CountVectorizer(), MultinomialNB()),
}
for name, pipe in setups.items():
    yp = cross_val_predict(pipe, df["text"], df["label"], cv=LeaveOneOut())
    tn, fp, fn, tp = confusion_matrix(df["label"], yp, labels=["ham", "spam"]).ravel()
    print(f"{name} accuracy {accuracy_score(df['label'], yp):.3f}  TN {tn} FP {fp} FN {fn} TP {tp}")

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0, pandas 3.0.2):

~/bazarghar-ai$ python nb_compare.py
scikit-learn 1.8.0 | 60 SMS, leave-one-out
Multinomial, words, alpha=1   accuracy 0.900  TN 29 FP 6 FN 0 TP 25
Multinomial, words, alpha=0.1 accuracy 0.867  TN 28 FP 7 FN 1 TP 24
Bernoulli, words, alpha=1     accuracy 0.733  TN 35 FP 0 FN 16 TP 9
Multinomial, char_wb 2-4      accuracy 0.867  TN 30 FP 5 FN 3 TP 22
Multinomial, default pattern  accuracy 0.817  TN 29 FP 6 FN 5 TP 20

ক্রম প্রায় উল্টে গেছে। ৬০টি বার্তা ধরে multinomial-শব্দ সেরা (০.৯০০, কোনো spam ছাড়া পায়নি, কিন্তু ৬টি আসল বার্তা spam), আর Bernoulli সবচেয়ে খারাপ (০.৭৩৩): এটি একটিও আসল বার্তা হারায় না, কারণ প্রায় সবকিছুকে ham বলে, ২৫টি spam-এর ১৬টি ছেড়ে দেয়। একটি সম্ভাব্য ব্যাখ্যা: Bernoulli প্রতিটি অনুপস্থিত শব্দের জন্যও log(1 − p_w) যোগ করে। Spam-এর উদাহরণ কম, তাই spam-এ দেখা শব্দের p_w বড়, আর একটি ছোট spam SMS-এ অন্য spam-এর বেশিরভাগ শব্দ থাকে না; সেই অনুপস্থিতি spam-এর score কমায়। ডেস্কটপে ভুল-বলা spam-গুলোর score ভেঙে দেখা গেছে, এই টান সত্যিই উপস্থিত শব্দের টানকে ছাপিয়ে যাচ্ছিল। ভাঙা default নিয়মও ০.৮১৭ পেয়েছে, তবে নিজের tokenizer-এর চেয়ে স্পষ্টতই খারাপ।

৮ · Model কী শিখল — সবচেয়ে তথ্যবহ শব্দ আর দুটি কঠিন বার্তা

Naive Bayes-এর একটি বড় গুণ: পুরো model খুলে পড়া যায়। log-odds লিখলে দেখা যায় এটি আসলে প্রতিটি শব্দের একটি ওজনের যোগফল:

log-odds = [log P(spam) − log P(ham)] + ∑_w count(w) × [log P(w | spam) − log P(w | ham)]

বন্ধনীর ভেতরের দ্বিতীয় পদটি প্রতিটি শব্দের log-probability ratio: ধনাত্মক হলে শব্দটি spam-এর দিকে টানে, ঋণাত্মক হলে ham-এর দিকে। Score তাই শব্দ-গোনার একটি রৈখিক যোগফল, অর্থাৎ multinomial NB আসলে একটি linear classifier; logistic regression-ও (পর্ব ৫৯) একই রূপের, শুধু ওজনগুলো অন্যভাবে শেখে। নিচের ব্লক ওজন অনুযায়ী শব্দ সাজায়, তারপর test set-এর যে আসল বার্তাগুলোকে spam বলা হয়েছিল, তার দুটি শব্দ ধরে ধরে খুলে দেখায়।

import numpy as np

# প্রতিটি শব্দের log P(w | spam) − log P(w | ham)
ratio = mnb.feature_log_prob_[1] - mnb.feature_log_prob_[0]
words = vec.get_feature_names_out()
up = np.argsort(-ratio, kind="stable")[:8]; down = np.argsort(ratio, kind="stable")[:8]
print("spam-এর দিকে:", [(words[i], round(float(ratio[i]), 2)) for i in up])
print("ham-এর দিকে: ", [(words[i], round(float(ratio[i]), 2)) for i in down])

# test set-এর যে ham গুলো spam বলা হয়েছে, শব্দ ধরে ধরে
wrong = [t for t, y, p in zip(te["text"], te["label"], pred) if y == "ham" and p == "spam"]
for text in wrong[:2]:
    print("\nSMS:", text)
    total = logprior["spam"] - logprior["ham"]
    print(f"  {'prior':<10} {total:+.2f}")
    for w in tokenize(text):
        if w not in vocab:
            print(f"  {w:<10}  অচেনা, বাদ")
            continue
        d = loglik(w, "spam") - loglik(w, "ham")
        total += d
        print(f"  {w:<10} {d:+.2f}  (spam-এ {counts['spam'][w]}, ham-এ {counts['ham'][w]} বার)")
    print(f"  মোট log-odds {total:+.2f} → {'spam' if total > 0 else 'ham'}")

spam-এর দিকে: [('otp', 2.07), ('ফ্রি', 1.94), ('এখনই', 1.6), ('করুন', 1.6), ('click', 1.38), ('আপনি', 1.38), ('কার্ড', 1.38), ('জিতেছেন', 1.38)]
ham-এর দিকে:  [('বাজারঘর', -2.4), ('bazarghar', -1.39), ('hoyeche', -1.39), ('অনেক', -1.39), ('কোড', -1.39), ('ডেলিভারি', -1.39), ('রাইডার', -1.39), ('er', -1.11)]

SMS: kal sokal e bazar e jabo. kichu lagle janaben
  prior      -0.31
  kal        -0.70  (spam-এ 0, ham-এ 1 বার)
  sokal       অচেনা, বাদ
  e          +1.09  (spam-এ 2, ham-এ 0 বার)
  bazar       অচেনা, বাদ
  e          +1.09  (spam-এ 2, ham-এ 0 বার)
  jabo        অচেনা, বাদ
  kichu       অচেনা, বাদ
  lagle       অচেনা, বাদ
  janaben    -0.70  (spam-এ 0, ham-এ 1 বার)
  মোট log-odds +0.47 → spam

SMS: ছোট ভাইয়ের ভর্তির ফি জমা দেওয়া হয়েছে। রসিদের ছবি পাঠালাম
  prior      -0.31
  ছোট         অচেনা, বাদ
  ভাইয়ের     অচেনা, বাদ
  ভর্তির      অচেনা, বাদ
  ফি         +1.09  (spam-এ 2, ham-এ 0 বার)
  জমা         অচেনা, বাদ
  দেওয়া      অচেনা, বাদ
  হয়েছে     -0.29  (spam-এ 2, ham-এ 3 বার)
  রসিদের      অচেনা, বাদ
  ছবি         অচেনা, বাদ
  পাঠালাম     অচেনা, বাদ
  মোট log-odds +0.48 → spam

দুই ভুলের দাম এক নয়

একটি false positive মানে আসল বার্তাকে spam বলা: “অর্ডার #4512 পাঠানো হয়েছে” বা লগইন কোড আড়ালে গেলে গ্রাহক রাইডারের ফোন ধরবেন না বা অ্যাপে ঢুকতে পারবেন না। একটি false negative মানে spam-কে ham বলা: একটি প্রতারণার SMS সতর্কবার্তা ছাড়াই পৌঁছায়, আর অসতর্ক গ্রাহক OTP দিয়ে টাকা হারাতে পারেন। কোনটি বেশি ক্ষতিকর, তা ব্যবসা ও নিরাপত্তা দলকে মিলে ঠিক করতে হয়। একটি সাধারণ কৌশল: spam ঘোষণার শর্ত কড়া করা, যেমন log-odds > ০-এর বদলে log-odds > ১. ডেস্কটপে একই ১৫টি test SMS-এ এটি চালিয়ে দেখা গেছে (সত্যিকারের run): সীমা ০-তে FP ৩, FN ০; সীমা ১-এ FP ১, FN ০; সীমা ৩-এ FP ০, FN ১. সীমা সরালে এক ভুল কমে, অন্যটি বাড়ে। এই হিসাবের পূর্ণ ভাষা (precision, recall, ROC) পর্ব ৬০ (মূল্যায়ন — accuracy, precision, recall, F1 আর ROC)-এর বিষয়.

৯ · Adversarial spam, Naive Bayes-এর সীমা আর একটু ইতিহাস

Spam ছাঁকা সাধারণ classification নয়, কারণ অপর পক্ষ চুপচাপ বসে থাকে না। প্রতারক জানেন filter শব্দ গোনে, তাই তিনি শব্দ বদলান। এমন ইচ্ছাকৃতভাবে বদলানো input-কে বলে adversarial example. তিনটি পরিচিত কৌশল আমাদের ৬০টি বার্তায় পুরো train করা দুটি model-এ পরীক্ষা করা হয়েছে: অক্ষরের মাঝে ফাঁকা জায়গা, শব্দের ভেতরে চোখে অদৃশ্য zero-width character (এখানে U+200C, zero-width non-joiner) ঢোকানো, আর বার্তার শেষে বাজারঘরের নিরীহ শব্দ জুড়ে দেওয়া। শেষটিকে গবেষণায় “good word attack” বলা হয়; Daniel Lowd আর Christopher Meek ২০০৫ সালে statistical spam filter-এর ওপর এর প্রভাব নিয়ে লিখেছিলেন।

for m in (word_nb, char_nb):
    m.fit(df["text"], df["label"])          # এখানে পুরো ৬০টি দিয়ে train

ZW = chr(0x200C)                            # চোখে অদৃশ্য zero-width non-joiner
tests = {
    "original": "অভিনন্দন! আপনি ফ্রি পুরস্কার জিতেছেন। এখনই লিংকে ক্লিক করুন",
    "spaced":   "অ ভি ন ন্দ ন! আপনি ফ ্রি পু র স্কা র জিতেছেন। এখনই লি ং কে ক্লি ক করুন",
    "zw-char":  f"অভি{ZW}নন্দন! আপনি ফ্{ZW}রি পুর{ZW}স্কার জিতে{ZW}ছেন। এখ{ZW}নই …",
    "padded":   "অভিনন্দন! … ক্লিক করুন বাজারঘর অর্ডার ডেলিভারি রাইডার ধন্যবাদ বাজারঘর রাইডার",
}
for name, text in tests.items():
    pw = word_nb.predict_proba([text])[0, spam_col]
    pc = char_nb.predict_proba([text])[0, spam_col]
    print(f"{name:<9} P(spam): words {pw:.3f} | char_wb {pc:.3f}")

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0; word_nb আর char_nb হলো অংশ ৭-এর দুই pipeline, কোডে “…” অংশে পুরো বাক্য):

~/bazarghar-ai$ python adversarial.py
original  P(spam): words 1.000 | char_wb 1.000
spaced    P(spam): words 0.998 | char_wb 1.000
zw-char   P(spam): words 0.742 | char_wb 1.000
padded    P(spam): words 0.817 | char_wb 0.000

ফাঁকা দেওয়ায় শব্দ-model টিকে গেছে, কারণ “আপনি”, “জিতেছেন”, “এখনই”, “করুন” অক্ষত ছিল; প্রতারক সব শব্দ ভাঙলে এটি ব্যর্থ হতো। অদৃশ্য অক্ষরে শব্দ-model-এর নিশ্চয়তা ০.৭৪২-এ নেমেছে: “ফ্রি” আর “পুরস্কার” এখন অচেনা token, অথচ মানুষের চোখে লেখা হুবহু একই। char n-gram দুই ক্ষেত্রেই অটল, কারণ ভাঙা শব্দের ভেতরেও অনেক চেনা টুকরো থাকে। কিন্তু ভালো শব্দ জুড়ে দিতেই char n-gram ভেঙে পড়েছে (০.০০০)! প্রতিটি জুড়ে দেওয়া শব্দ বহু ham-ঘেঁষা টুকরো আনে, আর naive অনুমানে প্রতিটি টুকরো আলাদা প্রমাণ, তাই ham-এর পক্ষে প্রমাণ ফুলে ওঠে। শব্দ-model-ও ১.০০০ থেকে ০.৮১৭-এ নেমেছে। predict_proba-র ১.০০০ আর ০.০০০ নিজেও সতর্কবার্তা: Naive Bayes-এর সম্ভাবনা সাধারণত calibrated নয়।

প্রতিরক্ষার সহজ ধাপ: clean()-এ zero-width অক্ষর মুছে ফেলা (অনুশীলন ২), শব্দ আর char feature মিলিয়ে ব্যবহার, লিংকের domain-এর মতো লেখার বাইরের সংকেত যোগ, আর নিয়মিত নতুন spam দিয়ে আবার train. তবু মৌলিক সীমা থাকে: Naive Bayes শব্দের ক্রম আর অর্থ দেখে না (“OTP কাউকে বলবেন না” আর “OTP বলুন” তার কাছে প্রায় এক), আর ছোট ডেটায় কাকতালীয় শব্দে ভোলে। ফোনে ঢোকা লিংকে কী করবেন না, সেই মানবিক দিক দেখুন Cybersecurity কোর্সের phishing প্রতিরক্ষা পর্বে।

১০ · AI-এর যুগে — AI assistant-এর লেখা text classifier যাচাই

“একটা spam classifier লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে চলনসই কোড দেয়। কিন্তু বাংলা লেখায় তার কয়েকটি ভুল খুব নিয়মিত, আর সেগুলো চোখে পড়ে না, কারণ কোড চলে এবং একটি সংখ্যাও ছাপে।

AI-এর লেখা classifier হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Tokenizer কয়েকটি আসল বাংলা ও Banglish বাক্যে চালিয়ে token চোখে দেখেছি; কার-চিহ্ন আর য়/ড় ঠিক আছে
• ভাগ আগে, fit পরে; test-এর কোনো বার্তা vocabulary বা smoothing-এ ঢোকেনি
• Accuracy-র পাশে confusion matrix, baseline আর n আছে; একটি ছোট ভাগের ফলকে চূড়ান্ত ধরিনি
• কয়েকটি ভুল বার্তা শব্দ ধরে ধরে খুলে দেখেছি কোন শব্দ সিদ্ধান্ত টেনেছে
• কোড নিজে চালিয়েছি, সব warning পড়েছি, API নিজের version-এর docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের SMS, ফোন নম্বর বা OTP AI-তে পেস্ট করিনি