القائمة
Supervised & unsupervised learning, scikit-learn, XGBoost, model evaluation, feature engineering for production ML
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/bouclem/skills --skill machine-learningيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
عرض SKILL.md
| name | machine-learning |
| description | Supervised & unsupervised learning, scikit-learn, XGBoost, model evaluation, feature engineering for production ML |
| sasmp_version | 1.3.0 |
| bonded_agent | 04-data-scientist |
| bond_type | PRIMARY_BOND |
| skill_version | 2.0.0 |
| last_updated | 2025-01 |
| complexity | intermediate |
| estimated_mastery_hours | 150 |
| prerequisites | ["python-programming","statistics-math"] |
| unlocks | ["deep-learning","mlops","llms-generative-ai"] |
Production-grade machine learning with scikit-learn, XGBoost, and modern ML engineering practices.
# Production ML Pipeline with scikit-learn
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score
import joblib
# Load and split data
df = pd.read_csv("data/customers.csv")
X = df.drop("churn", axis=1)
y = df["churn"]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# Define feature types
numeric_features = ["age", "tenure", "monthly_charges"]
categorical_features = ["contract_type", "payment_method"]
# Build preprocessing pipeline
numeric_transformer = Pipeline([
("imputer", SimpleImputer(strategy="median")),
("scaler", StandardScaler())
])
categorical_transformer = Pipeline([
("imputer", SimpleImputer(strategy="constant", fill_value="missing")),
(, OneHotEncoder(handle_unknown=, sparse_output=))
])
preprocessor = ColumnTransformer([
(, numeric_transformer, numeric_features),
(, categorical_transformer, categorical_features)
])
model = Pipeline([
(, preprocessor),
(, RandomForestClassifier(n_estimators=, random_state=))
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, ]
(classification_report(y_test, y_pred))
()
joblib.dump(model, )
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.preprocessing import FunctionTransformer
import numpy as np
class DateFeatureExtractor(BaseEstimator, TransformerMixin):
"""Custom transformer for date features."""
def __init__(self, date_column: str):
self.date_column = date_column
def fit(self, X, y=None):
return self
def transform(self, X):
X = X.copy()
dates = pd.to_datetime(X[self.date_column])
X["day_of_week"] = dates.dt.dayofweek
X["month"] = dates.dt.month
X["is_weekend"] = (dates.dt.dayofweek >= 5).astype(int)
X["days_since_epoch"] = (dates - pd.Timestamp("1970-01-01")).dt.days
return X.drop(self.date_column, axis=1)
class OutlierClipper(BaseEstimator, TransformerMixin):
"""Clip outliers to percentile bounds."""
def __init__(self, lower_percentile=1, upper_percentile=99):
self.lower_percentile = lower_percentile
self.upper_percentile = upper_percentile
self.bounds_ = {}
def fit(self, X, y=None):
for col in X.columns:
self.bounds_[col] = (
np.percentile(X[col], self.lower_percentile),
np.percentile(X[col], self.upper_percentile)
)
return self
def transform(self, X):
X = X.copy()
for col, (lower, upper) in self.bounds_.items():
X[col] = X[col].clip(lower, upper)
return X
# Log transform for skewed features
log_transformer = FunctionTransformer(
func=lambda x: np.log1p(np.maximum(x, 0)),
inverse_func=lambda x: np.expm1(x)
)
from sklearn.model_selection import (
StratifiedKFold, TimeSeriesSplit, GroupKFold,
cross_val_score, cross_validate
)
# Stratified K-Fold (for imbalanced classification)
stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(
model, X, y,
cv=stratified_cv,
scoring="roc_auc",
n_jobs=-1
)
print(f"ROC-AUC: {scores.mean():.4f} (+/- {scores.std()*2:.4f})")
# Time Series Split (for temporal data)
ts_cv = TimeSeriesSplit(n_splits=5, gap=7) # 7-day gap
for train_idx, test_idx in ts_cv.split(X):
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]
# Train and evaluate...
# Group K-Fold (prevent data leakage by user/entity)
group_cv = GroupKFold(n_splits=5)
groups = df["user_id"] # Same user never in train and test
scores = cross_val_score(
model, X, y,
cv=group_cv,
groups=groups,
scoring="roc_auc"
)
# Multiple metrics at once
results = cross_validate(
model, X, y,
cv=stratified_cv,
scoring=["accuracy", "precision", "recall", "f1", "roc_auc"],
return_train_score=True
)
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform
import optuna
# RandomizedSearchCV (good baseline)
param_dist = {
"classifier__n_estimators": randint(100, 500),
"classifier__max_depth": randint(3, 15),
"classifier__min_samples_split": randint(2, 20),
"classifier__min_samples_leaf": randint(1, 10),
}
random_search = RandomizedSearchCV(
model,
param_distributions=param_dist,
n_iter=50,
cv=stratified_cv,
scoring="roc_auc",
n_jobs=-1,
random_state=42,
verbose=1
)
random_search.fit(X_train, y_train)
print(f"Best params: {random_search.best_params_}")
print(f"Best score: {random_search.best_score_:.4f}")
# Optuna (modern, efficient)
def objective(trial):
params = {
"n_estimators": trial.suggest_int("n_estimators", 100, 500),
"max_depth": trial.suggest_int("max_depth", 3, 15),
"min_samples_split": trial.suggest_int("min_samples_split", 2, 20),
"learning_rate": trial.suggest_float("learning_rate", 0.01, 0.3, log=True),
}
model = XGBClassifier(**params, random_state=42)
scores = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc")
return scores.mean()
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100, n_jobs=-1)
print(f"Best params: {study.best_params}")
import xgboost as xgb
from sklearn.metrics import roc_auc_score
import matplotlib.pyplot as plt
# Prepare DMatrix for efficiency
dtrain = xgb.DMatrix(X_train, label=y_train, enable_categorical=True)
dtest = xgb.DMatrix(X_test, label=y_test, enable_categorical=True)
params = {
"objective": "binary:logistic",
"eval_metric": ["logloss", "auc"],
"max_depth": 6,
"learning_rate": 0.1,
"subsample": 0.8,
"colsample_bytree": 0.8,
"min_child_weight": 1,
"tree_method": "hist", # Fast histogram-based
"device": "cuda", # GPU if available
"random_state": 42,
}
# Train with early stopping
evals = [(dtrain, "train"), (dtest, "eval")]
model = xgb.train(
params,
dtrain,
num_boost_round=1000,
evals=evals,
early_stopping_rounds=50,
verbose_eval=100
)
# Feature importance
importance = model.get_score(importance_type="gain")
sorted_importance = dict(sorted(importance.items(), key=lambda x: x[1], reverse=True))
# SHAP values for interpretability
import shap
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test, plot_type="bar")
from imblearn.over_sampling import SMOTE, ADASYN
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.utils.class_weight import compute_class_weight
# Option 1: Class weights
class_weights = compute_class_weight("balanced", classes=np.unique(y_train), y=y_train)
weight_dict = dict(zip(np.unique(y_train), class_weights))
model = RandomForestClassifier(class_weight=weight_dict)
# Option 2: SMOTE oversampling
smote = SMOTE(random_state=42, sampling_strategy=0.5)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
# Option 3: Combined pipeline (recommended)
resampling_pipeline = ImbPipeline([
("preprocessor", preprocessor),
("smote", SMOTE(random_state=42)),
("classifier", RandomForestClassifier())
])
# Option 4: Threshold tuning
from sklearn.metrics import precision_recall_curve
y_prob = model.predict_proba(X_test)[:, 1]
precisions, recalls, thresholds = precision_recall_curve(y_test, y_prob)
# Find threshold for target recall
target_recall = 0.8
idx = np.argmin(np.abs(recalls - target_recall))
optimal_threshold = thresholds[idx]
y_pred_adjusted = (y_prob >= optimal_threshold).astype(int)
| Tool | Purpose | Version (2025) |
|---|---|---|
| scikit-learn | Core ML library | 1.4+ |
| XGBoost | Gradient boosting | 2.0+ |
| LightGBM | Fast gradient boosting | 4.2+ |
| CatBoost | Categorical boosting | 1.2+ |
| imbalanced-learn | Sampling strategies | 0.12+ |
| SHAP | Model interpretability | 0.44+ |
| Optuna | Hyperparameter tuning | 3.5+ |
| MLflow | Experiment tracking | 2.10+ |
Week 1: Supervised learning concepts, bias-variance
Week 2: Linear/logistic regression, evaluation metrics
Week 3: Decision trees, ensemble methods
Week 4: Cross-validation, train/test methodology
Week 5: Feature engineering, preprocessing
Week 6: Gradient boosting (XGBoost, LightGBM)
Week 7: Hyperparameter tuning strategies
Week 8: Handling imbalanced data
Week 9: Unsupervised learning (clustering, PCA)
Week 10: Model interpretability (SHAP, LIME)
Week 11: Time series forecasting
Week 12: Anomaly detection
Week 13: ML pipelines with scikit-learn
Week 14: Model serialization, versioning
Week 15: A/B testing for ML models
Week 16: Monitoring and retraining
| Issue | Symptoms | Root Cause | Fix |
|---|---|---|---|
| Overfitting | Train >> Test score | Model too complex | Regularization, cross-validation |
| Underfitting | Both scores low | Model too simple | More features, complex model |
| Data Leakage | Perfect CV, bad prod | Future info in features | Check feature timing |
| Class Imbalance | Low minority recall | Skewed class distribution | SMOTE, class weights, threshold |
| Covariate Shift | Model degrades over time | Data distribution changed | Monitor, retrain regularly |
# 1. Check data distribution
print(y.value_counts(normalize=True))
# 2. Verify no data leakage
# - Features computed before target event
# - No future information
# - No target encoding on full data
# 3. Learning curves
from sklearn.model_selection import learning_curve
train_sizes, train_scores, test_scores = learning_curve(
model, X, y, cv=5,
train_sizes=np.linspace(0.1, 1.0, 10),
scoring="roc_auc"
)
# 4. Feature importance analysis
importances = model.feature_importances_
sorted_idx = np.argsort(importances)[::-1]
# 5. Error analysis
errors = X_test[y_test != y_pred]
# Analyze patterns in misclassifications
import pytest
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from your_module import create_pipeline, train_model
@pytest.fixture
def sample_data():
X, y = make_classification(
n_samples=1000, n_features=20, n_informative=10,
n_redundant=5, random_state=42
)
return train_test_split(X, y, test_size=0.2, random_state=42)
class TestMLPipeline:
def test_pipeline_trains_successfully(self, sample_data):
X_train, X_test, y_train, y_test = sample_data
model = create_pipeline()
model.fit(X_train, y_train)
assert hasattr(model, "predict")
def test_predictions_valid_range(self, sample_data):
X_train, X_test, y_train, y_test = sample_data
model = create_pipeline()
model.fit(X_train, y_train)
predictions = model.predict_proba(X_test)[:, 1]
assert np.all(predictions >= 0)
assert np.all(predictions <= 1)
def test_model_better_than_random(self, sample_data):
X_train, X_test, y_train, y_test = sample_data
model = create_pipeline()
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
assert score > 0.5 # Better than random
def test_handles_missing_values(self):
X = np.array([[1, 2], [np.nan, 3], [4, np.nan]])
y = np.array([0, 1, 0])
model = create_pipeline()
model.fit(X, y)
predictions = model.predict(X)
assert len(predictions) == len(y)
# ✅ DO: Use pipelines for reproducibility
pipeline = Pipeline([
("preprocessor", preprocessor),
("model", model)
])
# ✅ DO: Stratify splits for classification
X_train, X_test, y_train, y_test = train_test_split(
X, y, stratify=y, random_state=42
)
# ✅ DO: Use appropriate metrics
# Classification: ROC-AUC, PR-AUC, F1
# Regression: RMSE, MAE, R²
# ❌ DON'T: Tune on test set
# ❌ DON'T: Feature engineer on full data
# ❌ DON'T: Ignore class imbalance
# ✅ DO: Version your models
import mlflow
mlflow.sklearn.log_model(model, "model")
mlflow.log_params(params)
mlflow.log_metrics({"auc": auc_score})
# ✅ DO: Monitor predictions
def monitor_predictions(predictions, reference_dist):
from scipy.stats import ks_2samp
stat, p_value = ks_2samp(predictions, reference_dist)
if p_value < 0.05:
alert("Distribution shift detected")
After mastering Machine Learning:
deep-learning - Neural networks with PyTorchmlops - Production ML systemsllms-generative-ai - Large language modelsstatistics-math - Deeper mathematical foundationsSkill Certification Checklist:
Multi-perspective academic paper review with dynamic reviewer personas. Simulates 5 independent reviewers (EIC + 3 peer reviewers + Devil's Advocate) with field-specific expertise. Supports full review, re-review (verification), quick assessment, methodology focus, Socratic guided, and calibration modes. Triggers on: review paper, peer review, manuscript review, referee report, review my paper, critique paper, simulate review, editorial review, calibrate reviewer, reviewer calibration, measure reviewer accuracy.
12-agent academic paper writing pipeline. 10 modes (full/plan/outline/revision/revision-coach/abstract/lit-review/format-convert/citation-check/disclosure). 6 paper types, 5 citation formats, bilingual abstracts, LaTeX/DOCX-via-Pandoc/PDF output. Style Calibration + Writing Quality Check + Anti-Patterns with IRON RULE markers. Triggers: write paper, academic paper, guide my paper, parse reviews, AI disclosure, 寫論文, 學術論文, 引導我寫論文, 審查意見.
Orchestrator for the full academic research pipeline: research -> write -> integrity check -> review -> revise -> re-review -> re-revise -> final integrity check -> finalize. Coordinates deep-research, academic-paper, and academic-paper-reviewer into a seamless 10-stage workflow with mandatory integrity verification, two-stage peer review, and reproducible quality gates. Triggers on: academic pipeline, research to paper, full paper workflow, paper pipeline, end-to-end paper, research-to-publication, complete paper workflow.
استنادا إلى تصنيف SOC المهني
