Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/bouclem/skills --skill machine-learningLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt 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.
Métiers associés SOC
Basé sur la classification professionnelle SOC
Explorateur de fichiers
6 fichiers 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"]
Machine Learning
Production-grade machine learning with scikit-learn, XGBoost, and modern ML engineering practices.
Quick Start
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
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
)
numeric_features = ["age" , "tenure" , "monthly_charges" ]
categorical_features = ["contract_type" , "payment_method" ]
numeric_transformer = Pipeline([
("imputer" , SimpleImputer(strategy="median" )),
("scaler" , StandardScaler())
])
categorical_transformer = Pipeline([
("imputer" , SimpleImputer(strategy="constant" , fill_value="missing" )),
("encoder"
"ignore"
False
"num"
"cat"
"preprocessor"
"classifier"
100
42
1
print
print
f"ROC-AUC: {roc_auc_score(y_test, y_prob):.4 f} "
"models/churn_model.joblib"
Core Concepts
1. Feature Engineering Pipeline 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_transformer = FunctionTransformer(
func=lambda x: np.log1p(np.maximum(x, 0 )),
inverse_func=lambda x: np.expm1(x)
)
2. Cross-Validation Strategies from sklearn.model_selection import (
StratifiedKFold, TimeSeriesSplit, GroupKFold,
cross_val_score, cross_validate
)
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():.4 f} (+/- {scores.std()*2 :.4 f} )" )
ts_cv = TimeSeriesSplit(n_splits=5 , gap=7 )
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]
group_cv = GroupKFold(n_splits=5 )
groups = df["user_id" ]
scores = cross_val_score(
model, X, y,
cv=group_cv,
groups=groups,
scoring="roc_auc"
)
results = cross_validate(
model, X, y,
cv=stratified_cv,
scoring=["accuracy" , "precision" , "recall" , "f1" , "roc_auc" ],
return_train_score=True
)
3. Hyperparameter Tuning from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform
import optuna
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_:.4 f} " )
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} " )
4. XGBoost Production Pattern import xgboost as xgb
from sklearn.metrics import roc_auc_score
import matplotlib.pyplot as plt
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" ,
"device" : "cuda" ,
"random_state" : 42 ,
}
evals = [(dtrain, "train" ), (dtest, "eval" )]
model = xgb.train(
params,
dtrain,
num_boost_round=1000 ,
evals=evals,
early_stopping_rounds=50 ,
verbose_eval=100
)
importance = model.get_score(importance_type="gain" )
sorted_importance = dict (sorted (importance.items(), key=lambda x: x[1 ], reverse=True ))
import shap
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test, plot_type="bar" )
5. Handling Imbalanced Data 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
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)
smote = SMOTE(random_state=42 , sampling_strategy=0.5 )
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
resampling_pipeline = ImbPipeline([
("preprocessor" , preprocessor),
("smote" , SMOTE(random_state=42 )),
("classifier" , RandomForestClassifier())
])
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)
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 )
Tools & Technologies 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+
Learning Path
Phase 1: Foundations (Weeks 1-4) 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
Phase 2: Intermediate (Weeks 5-8) Week 5: Feature engineering, preprocessing
Week 6: Gradient boosting (XGBoost, LightGBM)
Week 7: Hyperparameter tuning strategies
Week 8: Handling imbalanced data
Phase 3: Advanced (Weeks 9-12) Week 9: Unsupervised learning (clustering, PCA)
Week 10: Model interpretability (SHAP, LIME)
Week 11: Time series forecasting
Week 12: Anomaly detection
Phase 4: Production (Weeks 13-16) 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
Troubleshooting Guide
Common Failure Modes 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
Debug Checklist
print (y.value_counts(normalize=True ))
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"
)
importances = model.feature_importances_
sorted_idx = np.argsort(importances)[::-1 ]
errors = X_test[y_test != y_pred]
Unit Test Template 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
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)
Best Practices
Model Development
pipeline = Pipeline([
("preprocessor" , preprocessor),
("model" , model)
])
X_train, X_test, y_train, y_test = train_test_split(
X, y, stratify=y, random_state=42
)
Production Readiness
import mlflow
mlflow.sklearn.log_model(model, "model" )
mlflow.log_params(params)
mlflow.log_metrics({"auc" : auc_score})
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" )
Resources
Official Documentation
Courses
Books
"Hands-On Machine Learning" by Aurélien Géron
"The Elements of Statistical Learning"
"Feature Engineering for ML" by Alice Zheng
Next Skills After mastering Machine Learning:
→ deep-learning - Neural networks with PyTorch
→ mlops - Production ML systems
→ llms-generative-ai - Large language models
→ statistics-math - Deeper mathematical foundations
Skill Certification Checklist:
