ML coding ইন্টারভিউ — NumPy দিয়ে algorithm, pandas আর scikit-learn

import numpy as np
rng = np.random.default_rng(42)
n = 200
X = np.column_stack([rng.uniform(1, 30, n),      # দূরত্ব, km
                     rng.uniform(0.2, 8, n)])    # ওজন, kg
y = 2.0 + 0.8 * X[:, 0] + 1.5 * X[:, 1] + rng.normal(0, 2, n)   # ডেলিভারির ঘণ্টা

def fit_linear_gd(X, y, lr=0.1, epochs=2000):
    mu, sd = X.mean(axis=0), X.std(axis=0)
    Z = (X - mu) / sd                   # scale না করলে একটি lr সব দিকে চলে না
    w, b = np.zeros(Z.shape[1]), 0.0
    for _ in range(epochs):
        err = Z @ w + b - y             # shape (n,), (n, 1) নয়
        w -= lr * (Z.T @ err) / len(y)  # (1/2n)·Σerr²-এর gradient
        b -= lr * err.mean()
    return w / sd, b - (w / sd) @ mu    # মূল এককে ফেরত

w, b = fit_linear_gd(X, y)
A = np.column_stack([np.ones(n), X])
ref, *_ = np.linalg.lstsq(A, y, rcond=None)
print("GD    b, w:", np.round([b, *w], 4))
print("lstsq b, w:", np.round(ref, 4))
assert np.allclose([b, *w], ref, atol=1e-6)
print("max |diff| < 1e-6:", np.abs(np.r_[b, w] - ref).max() < 1e-6)

import numpy as np
from sklearn.linear_model import LogisticRegression
rng = np.random.default_rng(1)
n = 300
X = np.column_stack([rng.normal(0, 1, n), rng.normal(0, 1, n)])  # দিন থেকে শেষ অর্ডার, অভিযোগ (scaled)
z_true = -0.5 + 1.2 * X[:, 0] + 0.7 * X[:, 1]
y = (rng.random(n) < 1 / (1 + np.exp(-z_true))).astype(int)     # churn = 1

def sigmoid(z):
    return 0.5 * (1 + np.tanh(z / 2))       # exp-এর overflow ছাড়া একই ফল

def fit_logreg_gd(X, y, lr=0.5, epochs=3000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        w -= lr * X.T @ (p - y) / len(y)   # log loss-এর gradient: Xᵀ(p − y)/n
        b -= lr * (p - y).mean()
    z = X @ w + b
    loss = np.mean(np.logaddexp(0, z) - y * z)   # স্থির log loss
    return w, b, loss

w, b, loss = fit_logreg_gd(X, y)
sk = LogisticRegression(C=1e10, tol=1e-10, max_iter=1000).fit(X, y)  # C বিশাল = penalty নেই
print("GD      b, w:", np.round([b, *w], 4), "| log loss:", round(loss, 4))
print("sklearn b, w:", np.round([sk.intercept_[0], *sk.coef_[0]], 4))
assert np.allclose([b, *w], [sk.intercept_[0], *sk.coef_[0]], atol=1e-4)

import numpy as np
from scipy.special import logsumexp, softmax as sp_softmax
z = np.array([[1000., 1001., 1002.],     # বড় logit: naive exp() ভেঙে পড়ে
              [   1.,    2.,    3.]])
y = np.array([2, 0])                      # সঠিক class

def softmax_naive(z):
    e = np.exp(z)
    return e / e.sum(axis=1, keepdims=True)

def log_softmax(z):
    m = z.max(axis=1, keepdims=True)      # সারিপ্রতি সর্বোচ্চ বাদ: exp ≤ 1
    s = z - m
    return s - np.log(np.exp(s).sum(axis=1, keepdims=True))
def cross_entropy(z, y):
    return -log_softmax(z)[np.arange(len(y)), y].mean()
def ce_grad(z, y):                        # ∂CE/∂z = (softmax − one-hot)/n
    g = np.exp(log_softmax(z))
    g[np.arange(len(y)), y] -= 1
    return g / len(y)

print("naive :", softmax_naive(z)[0])
print("stable:", np.exp(log_softmax(z)).round(4).tolist())
print("CE    :", round(cross_entropy(z, y), 4))
ref = -(z - logsumexp(z, axis=1, keepdims=True))[np.arange(2), y].mean()
assert np.isclose(cross_entropy(z, y), ref)
assert np.allclose(np.exp(log_softmax(z)), sp_softmax(z, axis=1))
e = np.zeros_like(z); e[1, 2] = 1e-6      # finite difference দিয়ে gradient যাচাই
fd = (cross_entropy(z + e, y) - cross_entropy(z - e, y)) / 2e-6
print("grad[1,2]:", round(ce_grad(z, y)[1, 2], 6), "| finite diff:", round(fd, 6))

import numpy as np
from scipy.cluster.vq import kmeans2
rng = np.random.default_rng(0)
true_c = np.array([[2, 2], [8, 3], [5, 8]])            # তিনটি এলাকার কেন্দ্র (km)
X = np.vstack([c + rng.normal(0, 1, (50, 2)) for c in true_c])

def kmeans(X, C0, max_iter=100):
    C = C0.copy()
    for it in range(1, max_iter + 1):
        d2 = ((X[:, None, :] - C[None, :, :]) ** 2).sum(axis=2)   # (n, k)
        lab = d2.argmin(axis=1)                                     # assignment
        newC = np.array([X[lab == j].mean(axis=0) if (lab == j).any() else C[j]
                         for j in range(len(C))])                   # update
        if np.allclose(newC, C):
            break
        C = newC
    return C, lab, d2[np.arange(len(X)), lab].sum(), it

best = None
for seed in range(5):                                   # n_init = 5: সেরা inertia রাখি
    C0 = X[np.random.default_rng(seed).choice(len(X), 3, replace=False)]
    C, lab, inertia, it = kmeans(X, C0)
    print(f"seed {seed}: inertia {inertia:7.2f}, iterations {it}")
    if best is None or inertia < best[2]:
        best = (C, lab, inertia, C0)
C, lab, inertia, C0 = best
C_sp, lab_sp = kmeans2(X, C0, minit="matrix", iter=100)  # একই শুরু, SciPy-র Lloyd
assert np.allclose(C, C_sp) and (lab == lab_sp).all()
print("centres:", np.round(C[np.argsort(C[:, 0])], 2).tolist())

import numpy as np
from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
X = load_wine().data                      # scikit-learn-এর সাথে আসা Wine ডেটা: 178 × 13
X = (X - X.mean(axis=0)) / X.std(axis=0)  # মাপ আলাদা, তাই standardize

def pca_svd(X, k):
    Xc = X - X.mean(axis=0)               # center না করলে প্রথম অক্ষ গড়ের দিকে যায়
    U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
    evr = S**2 / (S**2).sum()             # explained variance ratio
    scores = Xc @ Vt[:k].T                # = U[:, :k] * S[:k]
    return scores, Vt[:k], evr[:k]

scores, comps, evr = pca_svd(X, 3)
sk = PCA(n_components=3).fit(X)
sign = np.sign((comps * sk.components_).sum(axis=1))   # প্রতিটি অক্ষের চিহ্ন মেলানো
print("shapes:", X.shape, "->", scores.shape)
print("ours   evr:", evr.round(4))
print("sklearn evr:", sk.explained_variance_ratio_.round(4))
assert np.allclose(comps * sign[:, None], sk.components_)
assert np.allclose(scores * sign, sk.transform(X))
print("same up to sign:", sign.astype(int).tolist())

import numpy as np
from sklearn.tree import DecisionTreeClassifier
rng = np.random.default_rng(3)
n = 120
X = np.column_stack([rng.integers(1, 60, n),          # দিন থেকে শেষ অর্ডার
                     rng.integers(0, 15, n)])         # মোট অর্ডার
y = ((X[:, 0] > 30) ^ (rng.random(n) < 0.15)).astype(int)   # churn, ১৫% noise

def best_split(X, y):
    """প্রতিটি feature-এ sort, তারপর cumsum দিয়ে সব threshold একবারে: O(d·n log n)."""
    n, best = len(y), (np.inf, None, None)
    for j in range(X.shape[1]):
        o = np.argsort(X[:, j], kind="stable")
        xs, ys = X[o, j], y[o]
        nl = np.arange(1, n)                       # বাঁয়ে 1..n-1 টি সারি
        pl = np.cumsum(ys)[:-1] / nl               # বাঁয়ের positive অনুপাত
        pr = (ys.sum() - np.cumsum(ys)[:-1]) / (n - nl)
        gini = (nl * 2 * pl * (1 - pl) + (n - nl) * 2 * pr * (1 - pr)) / n
        gini[xs[1:] == xs[:-1]] = np.inf           # সমান মানের মাঝে কাটা যায় না
        i = gini.argmin()
        if gini[i] < best[0]:
            best = (gini[i], j, (xs[i] + xs[i + 1]) / 2)
    return best

g, j, t = best_split(X, y)
tree = DecisionTreeClassifier(max_depth=1, random_state=0).fit(X, y)
print(f"ours   : feature {j}, threshold {t}, weighted gini {g:.4f}")
print(f"sklearn: feature {tree.tree_.feature[0]}, threshold {tree.tree_.threshold[0]}")
assert j == tree.tree_.feature[0] and np.isclose(t, tree.tree_.threshold[0])

import numpy as np
from scipy.stats import rankdata
from sklearn.metrics import roc_auc_score

def auc_rank(y, s):
    """Mann–Whitney: positive-গুলোর rank-যোগ থেকে। sort-এর জন্য O(n log n)."""
    y = np.asarray(y); r = rankdata(s)           # সমান score পায় গড় rank
    n1 = y.sum(); n0 = len(y) - n1
    if n1 == 0 or n0 == 0:
        raise ValueError("AUC needs both classes")
    return (r[y == 1].sum() - n1 * (n1 + 1) / 2) / (n1 * n0)

def auc_pairs(y, s):
    """সংজ্ঞা থেকে সরাসরি: সব (pos, neg) জোড়া, O(n1·n0)."""
    sp, sn = s[y == 1][:, None], s[y == 0][None, :]
    return ((sp > sn) + 0.5 * (sp == sn)).mean()

y = np.array([0, 0, 1, 1, 0, 1])
s = np.array([0.1, 0.4, 0.35, 0.8, 0.4, 0.4])    # তিনটি score সমান: 0.4
print(f"tiny  : rank {auc_rank(y, s):.4f} | pairs {auc_pairs(y, s):.4f} | sklearn {roc_auc_score(y, s):.4f}")

rng = np.random.default_rng(5)
y = rng.integers(0, 2, 2000)
s = np.round(y * 0.6 + rng.normal(0, 1, 2000), 1)  # এক দশমিকে গোল: অনেক tie
a, b, c = auc_rank(y, s), auc_pairs(y, s), roc_auc_score(y, s)
print(f"random: rank {a:.6f} | pairs {b:.6f} | sklearn {c:.6f}")
assert np.isclose(a, b) and np.isclose(a, c)

import numpy as np
from sklearn.model_selection import KFold

def kfold_indices(n, k, shuffle=False, seed=None):
    idx = np.arange(n)
    if shuffle:
        np.random.default_rng(seed).shuffle(idx)
    sizes = np.full(k, n // k)
    sizes[: n % k] += 1                       # প্রথম n % k টি fold-এ একটি বেশি
    start = 0
    for s in sizes:
        test = idx[start:start + s]
        yield np.setdiff1d(idx, test), test   # train sorted, test-এর বাইরে সব
        start += s

ours = list(kfold_indices(11, 3))
ref = list(KFold(n_splits=3).split(np.zeros(11)))
print("test folds:", [t.tolist() for _, t in ours])
assert all((a == c).all() and (b == d).all() for (a, b), (c, d) in zip(ours, ref))

rng = np.random.default_rng(8)
hours = rng.gamma(2.0, 12.0, 60)              # ৬০টি ডেলিভারির সময় (ঘণ্টা), ডানে লম্বা লেজ
B = 5000
boot = hours[rng.integers(0, len(hours), (B, len(hours)))]   # (B, n): একবারে সব resample
for name, f in [("mean", np.mean), ("median", np.median)]:
    lo, hi = np.percentile(f(boot, axis=1), [2.5, 97.5])
    print(f"{name:6s}: {f(hours):5.2f}  95% percentile CI [{lo:5.2f}, {hi:5.2f}]")
se = hours.std(ddof=1) / np.sqrt(len(hours))
print(f"normal CI for mean: [{hours.mean() - 1.96*se:5.2f}, {hours.mean() + 1.96*se:5.2f}]")

import numpy as np
import pandas as pd
rng = np.random.default_rng(9)
n = 40
orders = pd.DataFrame({
    "cust": rng.choice(["c1", "c2", "c3"], n),
    "ts": pd.Timestamp("2026-01-01") + pd.to_timedelta(rng.integers(0, 120, n), unit="D"),
    "taka": rng.integers(200, 2000, n)}).sort_values(["cust", "ts"], ignore_index=True)

def add_features(o):
    o = o.sort_values(["cust", "ts"], ignore_index=True)
    g = o.set_index("ts").groupby("cust")["taka"]
    # শুধু আগের ৩০ দিন: [ts − 30D, ts) — বর্তমান অর্ডার আর ভবিষ্যৎ বাদ
    o["spend_30d"] = g.rolling("30D", closed="left").sum().fillna(0).to_numpy()
    o["n_prev"] = o.groupby("cust").cumcount()            # এর আগে কয়টি অর্ডার
    o["leaky_total"] = o.groupby("cust")["taka"].transform("sum")   # বাগ: ভবিষ্যৎও যোগ
    return o

full = add_features(orders)
cut = pd.Timestamp("2026-03-01")
past = add_features(orders[orders["ts"] < cut])          # ভবিষ্যৎ মুছে আবার হিসাব
f_full = full[full["ts"] < cut].reset_index(drop=True)
for col in ["spend_30d", "n_prev", "leaky_total"]:
    same = np.array_equal(f_full[col].to_numpy(), past[col].to_numpy())
    print(f"{col:12s} unchanged without future rows: {same}")
print(full[full["cust"] == "c1"].head(4).to_string(index=False))

import pandas as pd
ev = pd.DataFrame({"user": ["u1"] * 5 + ["u2"] * 3,
    "ts": pd.to_datetime(["09:00", "09:10", "09:55", "10:05", "13:00",
                          "09:20", "09:45", "09:50"], format="%H:%M")})
ev = ev.sort_values(["user", "ts"], ignore_index=True)
gap = ev.groupby("user")["ts"].diff()                    # প্রতিটি user-এর ভেতরে বিরতি
new = gap.isna() | (gap > pd.Timedelta("30min"))         # প্রথম ঘটনা বা ৩০ মিনিটের বেশি
ev["session"] = new.cumsum()                             # gaps and islands
print(ev.assign(t=ev["ts"].dt.strftime("%H:%M"))[["user", "t", "session"]].T.to_string(header=False))

orders = pd.DataFrame({"cust": [1, 1, 2, 2, 3, 3, 3, 4, 5, 5],
    "month": pd.to_datetime(["2026-01", "2026-02", "2026-01", "2026-03", "2026-02",
        "2026-03", "2026-04", "2026-02", "2026-03", "2026-04"]).to_period("M")})
m = orders["month"].dt.year * 12 + orders["month"].dt.month   # মাসের পূর্ণসংখ্যা
orders["cohort"] = orders.groupby("cust")["month"].transform("min")
orders["age"] = m - m.groupby(orders["cust"]).transform("min")
active = orders.groupby(["cohort", "age"])["cust"].nunique().unstack(fill_value=0)
active = active.reindex(columns=range(m.max() - m.min() + 1), fill_value=0)
ret = active.div(active[0], axis=0)
seen = m.max() - (ret.index.year * 12 + ret.index.month).to_numpy()  # কত মাস দেখা গেছে
ret = ret.where(ret.columns.to_numpy()[None, :] <= seen[:, None]).round(2)
print(ret)                                               # NaN = এখনো দেখা হয়নি

import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
class CapLog(BaseEstimator, TransformerMixin):        # train-এর q-quantile-এ ছেঁটে log1p
    def __init__(self, q=0.99):
        self.q = q
    def fit(self, X, y=None):                         # cap_ শেখে শুধু fit-এ, মানে train fold-এ
        self.cap_ = np.quantile(np.asarray(X, dtype=float), self.q, axis=0)
        return self
    def transform(self, X):
        return np.log1p(np.minimum(np.asarray(X, dtype=float), self.cap_))
rng, n = np.random.default_rng(11), 600
df = pd.DataFrame({"district": rng.choice(["ঢাকা", "খুলনা", "সিলেট", "রংপুর"], n),
                   "spend": rng.lognormal(7, 1, n), "days_since": rng.integers(1, 90, n)})
df.loc[rng.random(n) < 0.1, "spend"] = np.nan                     # ১০% ফাঁকা
y = (rng.random(n) < 1 / (1 + np.exp(-(df["days_since"] - 45) / 15))).astype(int)
num = make_pipeline(SimpleImputer(strategy="median"), CapLog(), StandardScaler())
pre = ColumnTransformer([("num", num, ["spend", "days_since"]),
                         ("cat", OneHotEncoder(handle_unknown="ignore"), ["district"])])
pipe = make_pipeline(pre, LogisticRegression(max_iter=1000))
auc = cross_val_score(pipe, df, y, cv=StratifiedKFold(5, shuffle=True, random_state=0), scoring="roc_auc")
print("fold AUC:", auc.round(3), "| mean", auc.mean().round(3))
new = pd.DataFrame({"district": ["বান্দরবান"], "spend": [np.nan], "days_since": [80]})
print("unseen district, missing spend ->", pipe.fit(df, y).predict_proba(new)[:, 1].round(3))

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_auc_score
rng = np.random.default_rng(12)
df = pd.DataFrame({"km": rng.uniform(1, 30, 500)})
df["hours"] = 2 + 0.8 * df["km"] + rng.normal(0, 2, 500)

# বাগ ১: y-কে (n, 1) কলাম হিসেবে নেওয়া, pred (n,) — broadcasting নীরবে (n, n) বানায়
X, y_col = df[["km"]].to_numpy(), df[["hours"]].to_numpy()
pred = 2 + 0.8 * X[:, 0]
err = pred - y_col
print("bug  shape:", err.shape, "| MSE:", round((err**2).mean(), 2))
err = pred - y_col.ravel()                     # সমাধান: ravel, আর shape-এ assert
assert err.shape == (len(df),)
print("fix  shape:", err.shape, "| MSE:", round((err**2).mean(), 2))

# বাগ ২: ৫% positive-এ accuracy আর predict() দিয়ে AUC
x = rng.normal(0, 1, (2000, 1))
y = (rng.random(2000) < 1 / (1 + np.exp(-(x[:, 0] * 1.5 - 4)))).astype(int)
m = LogisticRegression().fit(x[:1000], y[:1000])
xt, yt = x[1000:], y[1000:]
print("positive rate:", yt.mean().round(3))
print("accuracy, model     :", round(accuracy_score(yt, m.predict(xt)), 3))
print("accuracy, all zeros :", round(accuracy_score(yt, np.zeros_like(yt)), 3))
print("AUC from predict()  :", round(roc_auc_score(yt, m.predict(xt)), 3))
print("AUC from proba      :", round(roc_auc_score(yt, m.predict_proba(xt)[:, 1]), 3))