Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat(ml): add stratified splitting with SMOTE oversampling
CarterPerez-devf9f8e1ef5237
diff --git a/PROJECTS/advanced/ai-threat-detection/backend/ml/splitting.py b/PROJECTS/advanced/ai-threat-detection/backend/ml/splitting.pynew file mode 100644index 00000000..89c91a91--- /dev/null+++ b/PROJECTS/advanced/ai-threat-detection/backend/ml/splitting.py@@ -0,0 +1,86 @@+"""+©AngelaMos | 2026+splitting.py+"""++from dataclasses import dataclass++import numpy as np+from imblearn.over_sampling import SMOTE+from sklearn.model_selection import train_test_split+++@dataclass+class TrainingSplit:+ """+ Result of stratified splitting with SMOTE oversampling+ """++ X_train: np.ndarray+ y_train: np.ndarray+ X_val: np.ndarray+ y_val: np.ndarray+ X_test: np.ndarray+ y_test: np.ndarray+ X_normal_train: np.ndarray+++def prepare_training_data(+ X: np.ndarray,+ y: np.ndarray,+ train_ratio: float = 0.70,+ val_ratio: float = 0.15,+ smote_strategy: float = 0.3,+ smote_k: int = 5,+ random_state: int = 42,+) -> TrainingSplit:+ """+ Split data into train/val/test with SMOTE on training set only+ """+ n_classes = len(np.unique(y))+ if n_classes < 2:+ raise ValueError(+ "y must contain at least 2 classes"+ )++ test_size = 1.0 - train_ratio+ X_train, X_rem, y_train, y_rem = train_test_split(+ X,+ y,+ test_size=test_size,+ stratify=y,+ random_state=random_state,+ )++ X_val, X_test, y_val, y_test = train_test_split(+ X_rem,+ y_rem,+ test_size=0.5,+ stratify=y_rem,+ random_state=random_state,+ )++ X_normal_train = X_train[y_train == 0]++ class_counts = np.bincount(y_train)+ minority_count = class_counts.min()++ if minority_count >= smote_k + 1:+ sampler = SMOTE(+ sampling_strategy=smote_strategy,+ k_neighbors=smote_k,+ random_state=random_state,+ )+ X_train, y_train = sampler.fit_resample(+ X_train, y_train+ )++ return TrainingSplit(+ X_train=X_train,+ y_train=y_train,+ X_val=X_val,+ y_val=y_val,+ X_test=X_test,+ y_test=y_test,+ X_normal_train=X_normal_train,+ )diff --git a/PROJECTS/advanced/ai-threat-detection/backend/tests/test_splitting.py b/PROJECTS/advanced/ai-threat-detection/backend/tests/test_splitting.pynew file mode 100644index 00000000..b907a7b4--- /dev/null+++ b/PROJECTS/advanced/ai-threat-detection/backend/tests/test_splitting.py@@ -0,0 +1,190 @@+"""+©AngelaMos | 2026+test_splitting.py+"""++import numpy as np+import pytest++from ml.splitting import TrainingSplit, prepare_training_data++N_NORMAL = 160+N_ATTACK = 40+N_FEATURES = 35+TOTAL = N_NORMAL + N_ATTACK+++def _make_dataset(+ n_normal: int = N_NORMAL,+ n_attack: int = N_ATTACK,+ n_features: int = N_FEATURES,+) -> tuple[np.ndarray, np.ndarray]:+ """+ Generate synthetic imbalanced dataset+ """+ rng = np.random.default_rng(42)+ X = rng.standard_normal(+ (n_normal + n_attack, n_features)+ ).astype(np.float32)+ y = np.array(+ [0] * n_normal + [1] * n_attack,+ dtype=np.int32,+ )+ return X, y+++class TestPrepareTrainingData:+ """+ Tests for stratified splitting with SMOTE+ """++ def test_returns_training_split(self) -> None:+ """+ Returns a TrainingSplit dataclass+ """+ X, y = _make_dataset()+ result = prepare_training_data(X, y)+ assert isinstance(result, TrainingSplit)++ def test_split_proportions(self) -> None:+ """+ Validates 70/15/15 split proportions+ """+ X, y = _make_dataset()+ result = prepare_training_data(X, y)+ expected_val = int(TOTAL * 0.15)+ expected_test = int(TOTAL * 0.15)+ tolerance = int(TOTAL * 0.05)+ assert abs(+ result.X_val.shape[0] - expected_val+ ) <= tolerance+ assert abs(+ result.X_test.shape[0] - expected_test+ ) <= tolerance++ def test_stratified_class_distribution(+ self,+ ) -> None:+ """+ Splits preserve the original class ratio+ """+ X, y = _make_dataset()+ original_ratio = np.mean(y == 1)+ result = prepare_training_data(X, y)+ val_ratio = np.mean(result.y_val == 1)+ test_ratio = np.mean(result.y_test == 1)+ ratio_tol = 0.10+ assert abs(+ val_ratio - original_ratio+ ) < ratio_tol+ assert abs(+ test_ratio - original_ratio+ ) < ratio_tol++ def test_smote_increases_minority(self) -> None:+ """+ SMOTE brings minority ratio near strategy+ """+ X, y = _make_dataset()+ result = prepare_training_data(+ X,+ y,+ smote_strategy=0.3,+ )+ minority = np.sum(result.y_train == 1)+ majority = np.sum(result.y_train == 0)+ ratio = minority / majority+ assert ratio >= 0.25++ def test_val_test_untouched(self) -> None:+ """+ Val test sizes match pre-SMOTE counts+ """+ X, y = _make_dataset()+ result = prepare_training_data(X, y)+ remainder = TOTAL - int(TOTAL * 0.70)+ half = remainder // 2+ tol = 3+ assert abs(+ result.X_val.shape[0] - half+ ) <= tol+ assert abs(+ result.X_test.shape[0] - half+ ) <= tol+ assert (+ result.X_val.shape[0]+ == result.y_val.shape[0]+ )+ assert (+ result.X_test.shape[0]+ == result.y_test.shape[0]+ )++ def test_x_normal_train_only_normals(+ self,+ ) -> None:+ """+ X_normal_train has only class-0 rows+ """+ X, y = _make_dataset()+ result = prepare_training_data(X, y)+ expected = int(N_NORMAL * 0.70)+ tol = int(TOTAL * 0.05)+ assert abs(+ result.X_normal_train.shape[0] - expected+ ) <= tol+ assert (+ result.X_normal_train.shape[1]+ == N_FEATURES+ )++ def test_small_dataset_works(self) -> None:+ """+ Small 50-sample dataset succeeds+ """+ X, y = _make_dataset(+ n_normal=40,+ n_attack=10,+ n_features=N_FEATURES,+ )+ result = prepare_training_data(+ X, y, smote_k=3+ )+ assert isinstance(result, TrainingSplit)+ assert result.X_train.shape[0] > 0+ assert result.X_val.shape[0] > 0+ assert result.X_test.shape[0] > 0++ def test_all_one_class_raises_value_error(+ self,+ ) -> None:+ """+ Single-class labels raise ValueError+ """+ rng = np.random.default_rng(99)+ X = rng.standard_normal(+ (100, N_FEATURES)+ ).astype(np.float32)+ y_zeros = np.zeros(100, dtype=np.int32)+ with pytest.raises(ValueError):+ prepare_training_data(X, y_zeros)+ y_ones = np.ones(100, dtype=np.int32)+ with pytest.raises(ValueError):+ prepare_training_data(X, y_ones)++ def test_smote_skipped_minority_too_small(+ self,+ ) -> None:+ """+ Tiny minority skips SMOTE gracefully+ """+ X, y = _make_dataset(+ n_normal=90,+ n_attack=10,+ n_features=N_FEATURES,+ )+ result = prepare_training_data(+ X, y, smote_k=50+ )+ assert isinstance(result, TrainingSplit)+ assert result.X_train.shape[0] > 0