Software Engineer Encyclopedia
0%
Domain 10 · Python, Machine Learning & Data Engineering · Topic 10.3 · Part 1/2

أساسيات Machine Learning — الجزء الأول

Machine Learning Fundamentals — Part 1

Problem framing, datasets, splits, preprocessing, baseline models and honest evaluation.

  • Intermediate
  • ~16 min read
  • 19 sections
  • 16 code examples
  • 1 diagrams
  • 9 questions
  • Priority L2 · Important
  • Python · Pandas · scikit-learn

بعد الدرس ده هتقدر

  • تربط كل خوارزمية كلاسيكية بشكل الحدود اللي تقدر تمثّله وتختار على الأساس ده.
  • تشخّص underfitting وoverfitting من فجوة train/validation وتعرف العلاج المناسب.
  • تستخدم K-Means وDBSCAN وPCA وتعرف حدود كل واحد ومقاييسه.

المتطلبات قبل ما تبدأ

أساسيات البرمجة والـ complexity. مش محتاج خبرة Python سابقة.

مستوى التعمق المطلوب

PRACTICALتفهم إزاي الموديل يتعلم من البيانات. ده التفصيل العملي بعد ما تخلص الـ Math اللي قبله، وبعده تدخل الـ Deep Learning.

01

صياغة المشكلة والبيانات

Problem framing, samples, features and labels
Deep dive

قبل اختيار algorithm، حدد القرار الذي تريد دعمه، من سيستخدم النتيجة، وما تكلفة false positive مقابل false negative. Dataset عبارة عن samples؛ كل sample له features، وقد يحمل label في supervised learning. Regression يتنبأ بقيمة مستمرة، Classification بفئة أو score، و Unsupervised learning يبحث عن structure دون labels.

افحص data dictionary، مصدر كل feature، وقت توفرها عند prediction، وحدود استخدامها القانونية. Feature لا تتوفر وقت inference تسبب leakage حتى لو حسّنت score في notebook.

PythonProblem framing, samples, features and labels
import pandas as pd

df = pd.read_csv("customers.csv")
print(df.shape)
print(df.dtypes)
print(df.isna().mean().sort_values(ascending=False).head())
print(df["churn"].value_counts(normalize=True))
02

الـ ML workflow في رسمة

The supervised ML workflow
Basics
DataSplittrain/val/test (time!)Pipelinefeatures + modelValidateCV, tune, baselineTest onceServeLeakage = any information from val/test (or the future) reaching training
Split before anything else; fit transforms on train only; touch the test set once
03

Train و Validation و Test دون Leakage

Honest experimental design
Deep dive

قسّم البيانات قبل أي preprocessing يتعلم من distribution. Train لتعلم parameters، validation لاختيار hyperparameters والقرار، و test لتقدير نهائي لا تلمسه أثناء التطوير. في time series استخدم split زمنيًا؛ وفي العملاء أو المرضى قد تحتاج group split حتى لا يظهر نفس الكيان في train و test.

Data leakage قد يأتي من target-derived columns، duplicate records، normalization قبل split، feature من المستقبل، أو اختيار test مرارًا. استخدم Pipeline حتى يتم fit للـ imputer/scaler/encoder داخل كل training fold.

PythonHonest experimental design
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)
model = Pipeline([
    ("impute", SimpleImputer(strategy="median")),
    ("scale", StandardScaler()),
    ("classifier", LogisticRegression(max_iter=1000))
])
model.fit(X_train, y_train)
04

Baseline ثم نماذج بسيطة

Linear/logistic regression and decision trees
Practical

ابدأ بـ baseline ساذج: predict mean/majority class أو business rule. لو نموذج معقد لا يتفوق بوضوح على baseline، راجع البيانات والهدف قبل زيادة التعقيد. Linear Regression تتعلم معاملات تقلل residual error؛ Logistic Regression تستخدم sigmoid/decision boundary لتصنيف احتمالي. Decision Tree تقسم features إلى قواعد، سهلة التفسير نسبيًا لكنها قد overfit. Random Forest تجمع أشجارًا لتقليل variance عبر bagging.

لا تفسر coefficient كسببية. افحص scaling و multicollinearity و outliers، واستخدم regularization: L1 قد ينتج sparsity، و L2 يقلل magnitudes بسلاسة.

PythonLinear/logistic regression and decision trees
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier

baseline = DummyClassifier(strategy="most_frequent")
baseline.fit(X_train, y_train)
forest = RandomForestClassifier(n_estimators=300, min_samples_leaf=3,
                                class_weight="balanced", random_state=42)
forest.fit(X_train, y_train)
05

Cleaning و Encoding و Feature Engineering

Prepare data without changing its meaning
Practical

افحص missingness: هل القيمة مفقودة عشوائيًا أم لها معنى؟ لا تملأ كل شيء بصفر تلقائيًا. Numeric features قد تحتاج median imputation و scaling؛ categorical features تحتاج OneHotEncoder أو encoding مناسب. لا تطبق encoding على test بشكل منفصل. Feature engineering يجب أن يحترم وقت التنبؤ ويُعاد بنفس المنطق في production.

تجنب identifiers كـ features إذا كانت تحفظ target leakage. راقب high-cardinality categories، rare values، skewed distributions، و outliers. ضع transformations داخل sklearn Pipeline و ColumnTransformer لضمان نفس preprocessing أثناء التدريب والتنبؤ.

PythonPrepare data without changing its meaning
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline

numeric = Pipeline([("impute", SimpleImputer(strategy="median")),
                    ("scale", StandardScaler())])
categorical = Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                        ("encode", OneHotEncoder(handle_unknown="ignore"))])
preprocess = ColumnTransformer([
    ("num", numeric, numeric_columns),
    ("cat", categorical, categorical_columns)
])
06

Evaluation Metrics و Confusion Matrix

Choose metrics from business costs
Deep dive

Accuracy قد تكون مضللة في class imbalance. Precision: من التنبؤات الإيجابية كم كان صحيحًا؟ Recall: من الإيجابيات الحقيقية كم اكتشفنا؟ F1 يوازن بينهما. ROC-AUC يقيس ranking عبر thresholds، و PR-AUC قد يكون أوضح مع rare positives. Regression يستخدم MAE و RMSE و R²، ولكل مقياس سلوك مختلف تجاه outliers.

Threshold ليس دائمًا 0.5؛ اختَره حسب تكلفة الأخطاء وقدرة فريق المراجعة. راقب confusion matrix على validation، ثم ثبّت القرار قبل test. Calibration مهمة عندما تستخدم probabilities لاتخاذ قرارات مالية أو تشغيلية.

PythonChoose metrics from business costs
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score

prob = model.predict_proba(X_test)[:, 1]
pred = (prob >= 0.35).astype(int)  # threshold chosen on validation, illustrative
print(confusion_matrix(y_test, pred))
print(classification_report(y_test, pred, zero_division=0))
print("ROC-AUC:", roc_auc_score(y_test, prob))

Confusion Matrix كقرار Business

افترض أن false negative يكلف 10 أضعاف false positive. Accuracy لا تمثل التكلفة. استخدم validation لتجربة thresholds، واحسب expected cost، precision/recall، وعدد الحالات التي يستطيع فريق المراجعة التعامل معها. ثبّت threshold قبل فتح test النهائي.

في class imbalance، راقب PR curve و precision at target recall. إذا تغير prevalence في الإنتاج، قد تتغير precision حتى لو بقي ranking quality ثابتًا. راقب calibration و re-evaluate على labels production بعد وصولها.

PythonThreshold and cost matrix
import numpy as np
from sklearn.metrics import confusion_matrix

cost_fp, cost_fn = 1, 10
for threshold in [0.2, 0.35, 0.5, 0.7]:
    pred = (validation_prob >= threshold).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_validation, pred).ravel()
    expected_cost = fp * cost_fp + fn * cost_fn
    print(threshold, {"fp": fp, "fn": fn, "cost": expected_cost})
07

Cross Validation و Hyperparameter Tuning

Estimate generalization and tune safely
Practical

Cross-validation تقسم train إلى folds، وتكرر fit/evaluate لتقليل اعتمادك على split واحد. لا تستخدمها عشوائيًا مع time series أو grouped observations. Grid Search يجرب شبكة محددة، Randomized Search أكثر كفاءة عندما توجد مساحة كبيرة. Hyperparameters مثل depth و learning rate و regularization ليست learned weights.

Gradient Boosting يبني learners بالتتابع لتصحيح أخطاء السابق، مثل XGBoost/LightGBM، وغالبًا قوي على tabular data لكنه يحتاج tuning وقياس. KNN و Naive Bayes و SVM اعرف متى تناسب، و k-means للتجميع مع اختيار k وفهم حساسيته لل scale.

PythonEstimate generalization and tune safely
from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier

search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    {"n_estimators": [200, 400], "max_depth": [None, 8, 16],
     "min_samples_leaf": [1, 3, 6]},
    n_iter=8, cv=StratifiedKFold(5, shuffle=True, random_state=42),
    scoring="average_precision", n_jobs=-1, random_state=42)
search.fit(X_train, y_train)
print(search.best_params_)
08

Cross-validation بدون تسريب

Pipelines inside folds
Deep dive

أي preprocessing يتعلم من البيانات يجب أن يتكرر داخل كل fold. لو عملت imputation أو scaling على كامل dataset قبل cross-validation، فإحصاءات validation تسربت إلى train. استخدم Pipeline/ColumnTransformer ثم cross-validation على pipeline كاملة. في time series لا تعمل random shuffle؛ استخدم chronological split أو TimeSeriesSplit. في بيانات customers متعددة الصفوف استخدم group-aware split حتى لا يتكرر customer في train و validation.

اعمل data audit قبل التدريب: duplicates، leakage columns، target definition، timestamp boundaries، label delay، و sampling. اكتب tests تثبت أن features المتاحة وقت inference فقط هي المستخدمة.

PythonPipelines inside folds
from sklearn.model_selection import cross_validate, StratifiedKFold

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
result = cross_validate(model, X_train, y_train, cv=cv,
                        scoring=["precision", "recall", "f1", "roc_auc"],
                        return_train_score=True)
print({k: result[f"test_{k}"].mean() for k in ["precision", "recall", "f1", "roc_auc"]})
لماذا نضع imputer داخل Pipeline؟
حتى يتعلم median من training fold فقط ولا يطلع على validation fold أثناء التقييم.
09

Feature Engineering و Data Leakage Checklist

Time-aware features and target boundaries
Deep dive

لكل feature اكتب: source، timestamp availability، transformation، missing policy، owner، و whether it can be known at prediction time. Features مثل days_until_cancellation قد تبدو predictive لكنها تستخدم future information. Aggregates يجب أن تكون computed as-of prediction timestamp، لا من كامل history.

راجع leakage عبر duplicate entities بين splits، target encoding قبل cross-validation، normalization على كامل data، post-outcome columns، و labels generated with future windows. أنشئ tests تقارن feature timestamp ب prediction timestamp. في time-series، استخدم rolling windows لا تتجاوز cutoff.

10

Baseline Selection و Bias–Variance Diagnosis

Diagnose before tuning
Practical

لو train score و validation score منخفضان معًا فقد يكون underfitting أو features ضعيفة أو label noise. لو train عالٍ و validation منخفض فغالبًا overfitting أو distribution shift. Bias/variance trade-off يساعد على تفسير السلوك، لكنه ليس تشخيصًا وحيدًا؛ افحص data quality و split و metrics.

ابدأ Dummy baseline، ثم linear/logistic، ثم tree/forest/boosting حسب tabular problem. لا تقفز إلى neural networks لمجرد أنها AI. سجل training time و inference latency والـ memory بجانب quality حتى تختار نموذجًا قابلًا للتشغيل.

11

الخوارزميات الكلاسيكية جنب بعض: نفس البيانات، نتايج مختلفة

Eight classifiers on three datasets — what each model can and cannot represent
Deep dive

حفظ أسماء الخوارزميات مش بيفيد. اللي بيفيد إنك تعرف شكل الحدود اللي كل خوارزمية تقدر ترسمها، وده اللي بيحدد هتنجح في أنهي مشكلة. التجربة دي بتشغّل 8 موديلات على 3 مجموعات بيانات ليها أشكال مختلفة، بنفس التقييم.

Pythoncompare_models.py — same protocol (5-fold CV accuracy) for every model and datasetExecuted ✓
import warnings; warnings.filterwarnings("ignore")
from sklearn.datasets import make_classification, make_circles, make_moons
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

datasets = {
    "linear":  make_classification(n_samples=600, n_features=2, n_redundant=0, n_informative=2, n_clusters_per_class=1, class_sep=1.2, random_state=1),
    "moons":   make_moons(n_samples=600, noise=0.25, random_state=1),
    "circles": make_circles(n_samples=600, noise=0.12, factor=0.45, random_state=1),
}
models = {
    "LogisticRegression":   make_pipeline(StandardScaler(), LogisticRegression()),
    "GaussianNB":           GaussianNB(),
    "KNN (k=15)":           make_pipeline(StandardScaler(), KNeighborsClassifier(15)),
    "SVM linear":           make_pipeline(StandardScaler(), SVC(kernel="linear")),
    "SVM RBF":              make_pipeline(StandardScaler(), SVC(kernel="rbf")),
    "DecisionTree (full)":  DecisionTreeClassifier(random_state=0),
    "RandomForest":         RandomForestClassifier(n_estimators=200, random_state=0),
    "GradientBoosting":     GradientBoostingClassifier(random_state=0),
}
print(f"{'model':<22}" + "".join(f"{d:>9}" for d in datasets))
for name, model in models.items():
    row = [cross_val_score(model, X, y, cv=5).mean() for X, y in datasets.values()]
    print(f"{name:<22}" + "".join(f"{v:9.3f}" for v in row))
ConsoleOutput — captured from a real run
model                    linear    moons  circles
LogisticRegression        0.945    0.852    0.463
GaussianNB                0.967    0.852    0.973
KNN (k=15)                0.962    0.932    0.982
SVM linear                0.960    0.848    0.512
SVM RBF                   0.960    0.932    0.982
DecisionTree (full)       0.968    0.898    0.970
RandomForest              0.968    0.927    0.977
GradientBoosting          0.967    0.923    0.972

اقرأ الجدول بالعمود: على البيانات الخطية كل الموديلات قريبة من بعض — يبقى اختار الأبسط والأسهل في التفسير. على circles الموديلات الخطية (Logistic، SVM linear) واقعة عند مستوى التخمين، لأن مفيش خط مستقيم يفصل دايرة جوه دايرة — مهما زودت البيانات.

GaussianNB على circles: نجح مع إنه «بسيط»، لأنه بيمثّل كل class بتوزيع له تباين مختلف، والحد بين توزيعين بتباينين مختلفين بيطلع منحني. الدرس: «بسيط» مش معناها «خطي».

الموديلشكل الحدمحتاج scaling؟قوي فيضعيف في
Logistic Regressionخط/مستوىأيوه (مع regularization)baseline، تفسير، احتمالات calibratedعلاقات غير خطية من غير feature engineering
Naive Bayesحسب التوزيع المفترضلأنص (bag of words)، بيانات قليلة، سرعةfeatures مرتبطة ببعض؛ احتمالاته متطرفة
KNNأي شكل (محلي)ضروريحدود معقدة ببيانات قليلة الأبعادأبعاد كتير، inference بطيء، حساس للـ noise
SVM (RBF)منحني ناعمضروريبيانات متوسطة الحجم، حدود معقدةبيانات ضخمة (التدريب بيتقل بسرعة)
Decision Treeدرجات سلم موازية للمحاورلأتفسير، تفاعلات بين featuresoverfitting لو اتساب يكبر
Random Forestمتوسط أشجار كتيرلأtabular بأقل ضبط، ثابتحجم الموديل، extrapolation
Gradient Boosting (XGBoost / LightGBM / CatBoost)مجموع أشجار صغيرةلأأقوى اختيار عام للـ tabularمحتاج ضبط و early stopping
XGBoost و LightGBM و CatBoost

التلاتة implementations لنفس فكرة الـ gradient boosting على الأشجار، بفروق هندسية: LightGBM بيكبّر الشجرة leaf-wise وسريع على البيانات الكبيرة، CatBoost بيتعامل مع الـ categorical features مباشرة بـ ordered target statistics، و XGBoost الأقدم والأوسع انتشارًا. HistGradientBoostingClassifier في scikit-learn من نفس العيلة (histogram-based) ومش محتاج مكتبة زيادة. المكتبات التلاتة مش متثبتة في بيئة تجهيز الموسوعة فمفيش مثال متنفذ ليهم هنا.

12

Bias–Variance بالأرقام: شجرة واحدة، أعماق مختلفة

Train vs validation score as model capacity grows; bagging reduces variance
Deep dive
Pythonbias_variance.py — depth sweep, then bagging and boosting on the same dataExecuted ✓
from sklearn.datasets import make_moons
from sklearn.ensemble import BaggingClassifier, GradientBoostingClassifier
from sklearn.model_selection import cross_validate
from sklearn.tree import DecisionTreeClassifier

X, y = make_moons(n_samples=500, noise=0.35, random_state=3)

def scores(model):
    r = cross_validate(model, X, y, cv=10, return_train_score=True)
    return r["train_score"].mean(), r["test_score"].mean(), r["test_score"].std()

print(f"{'model':<34}{'train':>7}{'valid':>7}{'gap':>7}{'std':>7}")
for depth in (1, 2, 4, 8, None):
    tr, va, sd = scores(DecisionTreeClassifier(max_depth=depth, random_state=0))
    print(f"{'tree depth=' + str(depth):<34}{tr:7.3f}{va:7.3f}{tr - va:7.3f}{sd:7.3f}")

deep_tree = DecisionTreeClassifier(max_depth=None, random_state=0)
tr, va, sd = scores(BaggingClassifier(deep_tree, n_estimators=200, random_state=0))
print(f"{'bagging: 200 deep trees':<34}{tr:7.3f}{va:7.3f}{tr - va:7.3f}{sd:7.3f}")
tr, va, sd = scores(GradientBoostingClassifier(n_estimators=100, max_depth=2, learning_rate=0.1, random_state=0))
print(f"{'boosting: 100 shallow trees':<34}{tr:7.3f}{va:7.3f}{tr - va:7.3f}{sd:7.3f}")
ConsoleOutput — captured from a real run
model                               train  valid    gap    std
tree depth=1                        0.801  0.768  0.033  0.058
tree depth=2                        0.886  0.846  0.040  0.036
tree depth=4                        0.896  0.838  0.058  0.035
tree depth=8                        0.958  0.820  0.138  0.042
tree depth=None                     1.000  0.810  0.190  0.040
bagging: 200 deep trees             1.000  0.860  0.140  0.037
boosting: 100 shallow trees         0.935  0.866  0.069  0.039

depth=1 (underfitting / high bias): train و validation الاتنين واطيين وقريبين من بعض. الموديل أبسط من المشكلة؛ بيانات أكتر مش هتساعد.

depth=None (overfitting / high variance): train = 1.000 (حفظ كل نقطة بالـ noise بتاعها) والـ validation أقل بفرق كبير. الـ gap هو العَرَض.

Bagging: نفس الأشجار العميقة اللي كانت overfit، لكن 200 منها كل واحدة على عيّنة bootstrap، والتصويت بياخد المتوسط. أخطاء الأشجار الفردية مختلفة فبتلغي بعض: الـ validation طلع. دي فكرة الـ Random Forest (+ اختيار عشوائي للـ features عند كل split).

Boosting: العكس: أشجار ضحلة (high bias) بتتبني بالتسلسل، كل واحدة بتصلّح أخطاء اللي قبلها. بيقلل الـ bias تدريجيًا، وعشان كده محتاج early stopping عشان ما يكمّلش لحد ما يحفظ.

13

Unsupervised: K-Means و DBSCAN و PCA على بيانات تعرف إجابتها

Clustering quality measured against known structure; PCA explained variance
Practical
Pythonunsupervised.py — where k-means fails, how to pick k, and what PCA keepsExecuted ✓
import numpy as np
from sklearn.cluster import DBSCAN, KMeans
from sklearn.datasets import load_iris, make_blobs, make_moons
from sklearn.decomposition import PCA
from sklearn.metrics import adjusted_rand_score, silhouette_score
from sklearn.preprocessing import StandardScaler

blobs, yb = make_blobs(n_samples=600, centers=3, cluster_std=0.8, random_state=4)
moons, ym = make_moons(n_samples=600, noise=0.06, random_state=4)

print("Adjusted Rand Index vs the true grouping (1.0 = perfect, ~0 = random):")
for name, X, y, k in [("3 blobs", blobs, yb, 3), ("2 moons", moons, ym, 2)]:
    Xs = StandardScaler().fit_transform(X)
    km = KMeans(n_clusters=k, n_init=10, random_state=0).fit_predict(Xs)
    db = DBSCAN(eps=0.3, min_samples=5).fit_predict(Xs)
    print(f"  {name:<8} k-means={adjusted_rand_score(y, km):.2f}   dbscan={adjusted_rand_score(y, db):.2f}  (dbscan found {len(set(db) - {-1})} clusters, {int((db == -1).sum())} noise points)")

print("\nchoosing k on the blobs with the silhouette score (no labels needed):")
Xs = StandardScaler().fit_transform(blobs)
for k in range(2, 7):
    labels = KMeans(n_clusters=k, n_init=10, random_state=0).fit_predict(Xs)
    print(f"  k={k}  silhouette={silhouette_score(Xs, labels):.3f}")

iris = StandardScaler().fit_transform(load_iris().data)
pca = PCA().fit(iris)
print("\nPCA on iris (4 features): explained variance ratio per component =", np.round(pca.explained_variance_ratio_, 3))
print("cumulative =", np.round(np.cumsum(pca.explained_variance_ratio_), 3))
ConsoleOutput — captured from a real run
Adjusted Rand Index vs the true grouping (1.0 = perfect, ~0 = random):
  3 blobs  k-means=0.99   dbscan=0.57  (dbscan found 2 clusters, 2 noise points)
  2 moons  k-means=0.49   dbscan=1.00  (dbscan found 2 clusters, 0 noise points)

choosing k on the blobs with the silhouette score (no labels needed):
  k=2  silhouette=0.796
  k=3  silhouette=0.619
  k=4  silhouette=0.575
  k=5  silhouette=0.543
  k=6  silhouette=0.392

PCA on iris (4 features): explained variance ratio per component = [0.73  0.229 0.037 0.005]
cumulative = [0.73  0.958 0.995 1.   ]

K-Means على الـ moons فشل لأنه بيفترض إن كل cluster كورة حوالين مركز، وبيقسم الفضاء بخطوط مستقيمة بين المراكز. الهلالين متداخلين فمفيش خط يفصلهم. DBSCAN بيتبع الكثافة (نقطة قريبة من نقطة قريبة من نقطة…) فبيلقط أي شكل، ومش محتاج عدد الـ clusters مسبقًا — لكنه حساس جدًا لـ eps، ولازم scaling.

DBSCAN على الـ blobs دمج مجموعتين في واحدة (لقى 2 بس) لأن eps=0.3 كان واسع كفاية يوصّل بينهم. نفس الإعداد اللي نجح تمامًا على الـ moons فشل هنا — DBSCAN حساس جدًا لـ eps ومحتاج ضبط لكل dataset.

الـ silhouette اختار k=2 مش 3 — مع إننا عارفين إن الحقيقة 3. السبب إن مجموعتين من التلاتة قريبين من بعض، فدمجهم بيدّي clusters «أنضف» بالمقياس ده. الدرس: مقاييس الـ clustering الداخلية بتقيس شكل التقسيم مش صحته. استخدمها كمؤشر، والقرار النهائي بيعتمد على هل الـ clusters ليها معنى في الـ domain.

PCA: أول مكوّنين شايلين أغلب التباين في الـ 4 features. ده معناه إنك تقدر ترسم البيانات في بُعدين من غير ما تخسر كتير. تحذير: PCA بيحافظ على التباين مش على القدرة على التنبؤ — مكوّن تباينه صغير ممكن يكون هو اللي بيفرّق بين الـ classes.

هتعمل KNN على features: العمر (20–70) والدخل السنوي (20,000–500,000). لو نسيت الـ scaling؟

14

Hyperparameter Optimization: Grid ولا Random ولا Halving — والرقم اللي تصدّقه

Search strategies under the same budget, and why the best CV score is optimistic — executed
Practical

الـ hyperparameters (عمق الشجرة، الـ learning rate، قوة الـ regularization) مش بتتعلم من البيانات — إنت اللي بتختارها. السؤالين المهمين: إزاي تدوّر بكفاءة؟ ولما تلاقي «أحسن إعداد»، هل الـ score بتاعه رقم تقدر تبلّغه؟

Pythonhpo.py — equal budgets for grid and random search, successive halving, and nested CVExecuted ✓
import time, warnings; warnings.filterwarnings("ignore")
import numpy as np
from scipy.stats import loguniform, randint
from sklearn.datasets import make_classification
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.experimental import enable_halving_search_cv  # noqa: F401
from sklearn.model_selection import GridSearchCV, HalvingRandomSearchCV, RandomizedSearchCV, cross_val_score, train_test_split

X, y = make_classification(n_samples=1500, n_features=20, n_informative=5, flip_y=0.1, random_state=0)
X_dev, X_test, y_dev, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0)
base = GradientBoostingClassifier(random_state=0)

grid = {"learning_rate": [0.01, 0.1, 0.5], "max_depth": [1, 3, 5], "n_estimators": [50, 150], "subsample": [0.6, 1.0]}   # 36 combos
dist = {"learning_rate": loguniform(0.005, 0.5), "max_depth": randint(1, 7), "n_estimators": randint(30, 200), "subsample": [0.6, 0.8, 1.0]}

def run(name, search):
    t0 = time.perf_counter(); search.fit(X_dev, y_dev)
    fits = len(search.cv_results_["params"])
    print(f"{name:<34} configs tried={fits:>3}  best CV={search.best_score_:.4f}  held-out test={search.score(X_test, y_test):.4f}  time={time.perf_counter() - t0:5.1f}s")
    return search

print("search on the development set (3-fold CV, metric = accuracy):")
run("grid search (36 configs)", GridSearchCV(base, grid, cv=3, n_jobs=-1))
best = run("random search (36 configs)", RandomizedSearchCV(base, dist, n_iter=36, cv=3, random_state=0, n_jobs=-1))
halving_space = {k: v for k, v in dist.items() if k != "n_estimators"}        # n_estimators is the resource being rationed
run("successive halving (random start)", HalvingRandomSearchCV(base, halving_space, cv=3, factor=3, resource="n_estimators",
                                                                 max_resources=200, min_resources=20, random_state=0, n_jobs=-1))

print("\nbest random-search config:", {k: (round(float(v), 4) if isinstance(v, float) else int(v)) for k, v in best.best_params_.items()})

# ---------- is "best CV score" an honest estimate? nested CV says how optimistic it is ----------
inner = RandomizedSearchCV(base, dist, n_iter=12, cv=3, random_state=0, n_jobs=-1)
nested = cross_val_score(inner, X_dev, y_dev, cv=4)                 # the WHOLE search is repeated inside each outer fold
inner.fit(X_dev, y_dev)
print(f"\nrandom search (12 configs): best inner-CV score = {inner.best_score_:.4f}")
print(f"nested CV estimate of the tuned pipeline       = {nested.mean():.4f} ± {nested.std():.4f}")
print(f"held-out test score                             = {inner.score(X_test, y_test):.4f}")
ConsoleOutput — captured from a real run
search on the development set (3-fold CV, metric = accuracy):
grid search (36 configs)           configs tried= 36  best CV=0.8552  held-out test=0.8533  time= 16.7s
random search (36 configs)         configs tried= 36  best CV=0.8629  held-out test=0.8644  time= 19.9s
successive halving (random start)  configs tried= 16  best CV=0.8571  held-out test=0.8578  time=  5.1s

best random-search config: {'learning_rate': 0.0215, 'max_depth': 6, 'n_estimators': 199, 'subsample': 0.6}

random search (12 configs): best inner-CV score = 0.8476
nested CV estimate of the tuned pipeline       = 0.8476 ± 0.0142
held-out test score                             = 0.8400

Grid vs Random بنفس الميزانية: الـ grid بيجرّب 3 قيم بس للـ learning rate مهما زاد عدد التجارب؛ الـ random بيجرّب 36 قيمة مختلفة لكل parameter. لما parameter واحد أو اتنين هم اللي بيفرقوا (وده الغالب)، الـ random بيغطيهم أحسن. استخدم توزيع log-uniform للـ parameters اللي بتتغير بالمضاعفات (learning rate، C، alpha).

Successive halving: ابدأ بإعدادات كتير بموارد قليلة (هنا عدد أشجار صغير)، ارمي الأضعف، وزوّد الموارد للباقي. هنا وصل لنتيجة قريبة من الـ random search في حوالي ربع الوقت. الـ Bayesian optimization (Optuna وغيره) بياخد خطوة أبعد: بيستخدم نتايج التجارب السابقة عشان يختار التجربة الجاية — مفيد لما كل تجربة غالية.

الرقم اللي تصدّقه: «best CV score» هو أعلى رقم من N محاولة على نفس الـ folds، فمن حيث المبدأ فيه جزء حظ. الـ nested CV بيكرر البحث كله جوه كل fold خارجي فبيدّي تقدير أمين لأداء «الـ pipeline بالـ tuning بتاعه». في التجربة دي الرقمين طلعوا متطابقين تقريبًا (12 إعداد بس على 1050 صف — التفاؤل صغير)، والـ test set المعزول أقل منهم بحوالي نقطة وجوه هامش الـ ±0.014. التفاؤل بيكبر كل ما عدد الإعدادات يزيد والبيانات تقل: مع مئات التجارب على مئات الصفوف الفرق بيبقى واضح. القاعدة ثابتة: الرقم اللي بتبلّغه ييجي من بيانات ما شاركتش في الاختيار.

جرّبت 500 إعداد واخترت الأحسن بـ CV score = 0.94، وبلّغت الرقم ده كأداء الموديل. إيه المشكلة؟

15

اختبر فهمك

Knowledge Check
Practical
هل نعمل scaling على كامل dataset قبل train/test split؟
لا. fit preprocessing على training data فقط داخل Pipeline حتى لا يحدث leakage.
متى تكون Recall أهم من Precision؟
عندما تكون تكلفة تفويت الحالات الإيجابية أعلى من تكلفة الإنذارات الكاذبة، مثل فحص حالات خطرة.

اختبار الإتقان المهني

لماذا نضع preprocessing داخل cross-validation pipeline؟
حتى يتم fit للـ imputer/scaler/encoder داخل training fold فقط، فلا تتسرب معلومات validation إلى التدريب.
متى يكون Group Split أفضل من random split؟
عندما توجد عدة records لنفس entity مثل customer أو patient؛ يجب منع ظهور نفس المجموعة في train و test.
ما الفرق بين empirical risk و expected risk؟
Empirical risk متوسط loss على العينة التدريبية، أما expected risk فهو الأداء المتوقع على distribution المستقبلية المستهدفة.
16

Supervised Learning Objective and Empirical Risk

What training actually minimizes
Deep dive

Supervised dataset هو أزواج (xᵢ,yᵢ). النموذج fθ يحول x إلى prediction، و training يختار θ لتقليل empirical risk: متوسط loss على training examples، مع regularization عند الحاجة. الهدف ليس حفظ training data بل تقليل expected risk على future samples من distribution الهدف. هذا هو سبب وجود train/validation/test، وسبب أن dataset shift يجعل الأداء يتغير بعد النشر.

Regularization يضيف penalty مثل L1 أو L2 إلى objective. L2 يدفع weights إلى قيم أصغر وغالبًا يحسن الاستقرار، و L1 قد ينتج sparsity. لكن regularization لا يعالج leakage أو labels فاسدة أو split غير ممثل. افهم العلاقة بين objective و business metric: تحسين log-loss لا يضمن تلقائيًا زيادة revenue.

PythonWhat training actually minimizes
# A tiny linear regression objective with L2 regularization
import numpy as np
X = np.array([[1., 1.], [1., 2.], [1., 3.]])
y = np.array([2., 4., 6.])
theta = np.linalg.solve(X.T @ X + 0.1*np.eye(2), X.T @ y)
pred = X @ theta
mse = np.mean((pred-y)**2)
print(np.round(theta, 3), round(mse, 4))
17

Train / Validation / Test Protocols and Group Splits

Split design is part of the experiment
Deep dive

Random split مناسب فقط عندما تكون observations مستقلة وممثلة. لو عدة rows لنفس customer أو patient أو device، استخدم group split حتى لا يتعلم النموذج هوية الكيان من train ثم يراه في test. في time series استخدم chronological split، وقد تحتاج gap/embargo لمنع تداخل label windows. Stratification تحافظ تقريبًا على class proportions لكنها لا تحل group/time leakage.

Test set يظل مغلقًا حتى نهاية اختيار model/hyperparameters. إذا رجعت إليه بعد كل تعديل فهو أصبح validation set ضمنيًا. احتفظ ب split manifest يحدد row IDs أو entity IDs وإصدار البيانات والبذرة، وراجع duplicates قبل التقسيم وبعده.

PythonSplit design is part of the experiment
from sklearn.model_selection import GroupShuffleSplit
import numpy as np

X = np.arange(24).reshape(12, 2)
y = np.array([0,1]*6)
groups = np.repeat(np.arange(6), 2)  # two rows per customer
splitter = GroupShuffleSplit(n_splits=1, test_size=.33, random_state=7)
train_idx, test_idx = next(splitter.split(X, y, groups))
assert set(groups[train_idx]).isdisjoint(set(groups[test_idx]))
print(len(train_idx), len(test_idx))
18

Preprocessing Pipelines and Leakage-Safe Cross Validation

Fit transforms only on training folds
Deep dive

Imputation، scaling، encoding، feature selection، PCA، target encoding كلها transforms قد تتعلم parameters من data. القاعدة: fit على training fold فقط، ثم transform على validation/test. استخدام Pipeline من scikit-learn يجعل preprocessing جزءًا من estimator ويقلل فرص leakage داخل cross-validation. لا تعمل fit_transform على كامل dataset قبل تقسيمها.

ColumnTransformer يسمح بمعالجة numeric و categorical features بطرق مختلفة. تعامل مع unseen categories، missingness، sparse matrices، و schema drift. عند deployment خزّن preprocessing مع model artifact؛ model بدون نفس transform ليس نفس النظام.

PythonFit transforms only on training folds
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression

numeric = Pipeline([('impute', SimpleImputer(strategy='median')), ('scale', StandardScaler())])
categorical = Pipeline([('impute', SimpleImputer(strategy='most_frequent')), ('encode', OneHotEncoder(handle_unknown='ignore'))])
pre = ColumnTransformer([('num', numeric, ['age']), ('cat', categorical, ['city'])])
model = Pipeline([('pre', pre), ('clf', LogisticRegression(max_iter=1000))])
# Fit model.fit(X_train, y_train); evaluate only on held-out X_valid.
19

Learning Curves, Error Analysis and Data-Centric Iteration

Find the limiting factor before changing algorithms
Deep dive

Learning curve تقارن training/validation performance مع زيادة training data أو model capacity. High train and validation error غالبًا high bias/underfitting؛ low train error مع high validation error غالبًا variance/overfitting. لكن افحص label noise، split mismatch، class imbalance، و feature availability قبل التشخيص.

Error analysis يعني فحص عينات فشل النموذج وتصنيف أسبابها: ambiguous label، missing feature، rare subgroup، bad OCR، temporal shift، أو threshold choice. أنشئ slices حسب language/region/device/customer segment مع حماية الخصوصية. التحسين الجيد غالبًا يبدأ بإصلاح dataset أو labeling guideline بدل تبديل model عشوائيًا.

PythonFind the limiting factor before changing algorithms
# A simple slice-based error report
import numpy as np
truth = np.array([1,0,1,1,0,0,1,0])
pred  = np.array([1,1,0,1,0,1,1,0])
segment = np.array(['A','A','A','B','B','B','B','A'])
for group in np.unique(segment):
    mask = segment == group
    error_rate = np.mean(truth[mask] != pred[mask])
    print(group, int(mask.sum()), round(float(error_rate), 3))
↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

خريطة التغطية: 36 عنصر من الـ Roadmap ومكان شرحه في الدرس
RoadmapDataset, Features, Labels§01
RoadmapTraining, Validation, Testing§01
RoadmapSupervised vs. Unsupervised Learning§01
RoadmapRegression & Classification§04
RoadmapLinear Regression, Logistic Regression§04
RoadmapDecision Trees, Random Forest§04
RoadmapPython for Data Science§01
RoadmapNumPy§01
RoadmapPandas§01
RoadmapData Cleaning§01
RoadmapData Visualization§01
RoadmapEvaluation Metrics§06
RoadmapOverfitting and Underfitting§03
RoadmapFeature Engineering§05
Roadmapscikit-learn§18
RoadmapModel Serialization§19
RoadmapModel Serving§19
Roadmap.NET Integration§19
RoadmapModel Versioning Basics§19
RoadmapModel Monitoring Basics§19
SuggestedBaseline models first§03
SuggestedBias-variance trade-off§03
SuggestedOverfitting, underfitting, regularization (L1, L2)§03
SuggestedCross-validation§03
SuggestedHyperparameter tuning (grid, random search)§07
SuggestedMetrics: accuracy, precision, recall, F1, ROC-AUC, RMSE, MAE, R²§06
SuggestedConfusion matrix and choosing the right metric§06
SuggestedClass imbalance (class weights, resampling)§06
SuggestedData leakage (the classic silent bug)§03
SuggestedMissing values, scaling, encoding categorical data§05
Suggestedk-Nearest Neighbors, Naive Bayes, SVM (awareness)§04
SuggestedEnsembles: bagging vs boosting§07
SuggestedGradient boosting: XGBoost, LightGBM§07
SuggestedClustering: k-Means§07
SuggestedDimensionality reduction: PCA§07
SuggestedPandas and scikit-learn pipelines§05

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس