
Machine Learning
- 3 installs
- 404 repo stars
- Updated August 5, 2026
- aiskillstore/marketplace
This is a copy of machine-learning by 89jobrien - installs and ranking accrue to the original listing.
machine-learning is a Claude Code skill covering the full ML lifecycle, from feature engineering and model training to deployment and monitoring.
About
machine-learning is a Claude Code skill covering the full machine-learning lifecycle from data preparation to production deployment. A developer uses it for feature engineering, model selection, hyperparameter tuning, evaluation, and MLOps concerns like experiment tracking, model versioning and drift monitoring. It provides algorithm-selection guides, metric tables and serving patterns.
- Covers the full ML lifecycle from experimentation to production
- Feature engineering, model selection and hyperparameter tuning guidance
- MLOps: experiment tracking, model versioning and drift monitoring
Machine Learning by the numbers
- 3 all-time installs (skills.sh)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
machine-learning capabilities & compatibility
- Capabilities
- feature engineering · model selection · hyperparameter tuning · model evaluation · ml deployment
- Use cases
- data analysis
What machine-learning says it does
Comprehensive machine learning skill covering the full ML lifecycle from experimentation to production deployment.
Resampling: SMOTE, undersampling
npx skills add https://github.com/aiskillstore/marketplace --skill machine-learningAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 3 |
|---|---|
| repo stars | ★ 404 |
| Last updated | August 5, 2026 |
| Repository | aiskillstore/marketplace ↗ |
What it does
Build and deploy an ML pipeline with feature engineering, model selection and MLOps monitoring.
Who is it for?
Building ML pipelines and taking models from experimentation to production
When should I use this skill?
Building ML pipelines, training models, feature engineering, or deploying ML systems
What you get
- ML pipeline
- trained model
- evaluation report
By the numbers
- 7-step ML development lifecycle
- algorithm selection guide across 3 data-size tiers
- 3 reference files (preprocessing, model patterns, evaluation)
Files
Machine Learning
Comprehensive machine learning skill covering the full ML lifecycle from experimentation to production deployment.
When to Use This Skill
- Building machine learning pipelines
- Feature engineering and data preprocessing
- Model training, evaluation, and selection
- Hyperparameter tuning and optimization
- Model deployment and serving
- ML experiment tracking and versioning
- Production ML monitoring and maintenance
ML Development Lifecycle
1. Problem Definition
Classification Types:
- Binary classification (spam/not spam)
- Multi-class classification (image categories)
- Multi-label classification (document tags)
- Regression (price prediction)
- Clustering (customer segmentation)
- Ranking (search results)
- Anomaly detection (fraud detection)
Success Metrics by Problem Type:
| Problem Type | Primary Metrics | Secondary Metrics |
|---|---|---|
| Binary Classification | AUC-ROC, F1 | Precision, Recall, PR-AUC |
| Multi-class | Macro F1, Accuracy | Per-class metrics |
| Regression | RMSE, MAE | R², MAPE |
| Ranking | NDCG, MAP | MRR |
| Clustering | Silhouette, Calinski-Harabasz | Davies-Bouldin |
2. Data Preparation
Data Quality Checks:
- Missing value analysis and imputation strategies
- Outlier detection and handling
- Data type validation
- Distribution analysis
- Target leakage detection
Feature Engineering Patterns:
- Numerical: scaling, binning, log transforms, polynomial features
- Categorical: one-hot, target encoding, frequency encoding, embeddings
- Temporal: lag features, rolling statistics, cyclical encoding
- Text: TF-IDF, word embeddings, transformer embeddings
- Geospatial: distance features, clustering, grid encoding
Train/Test Split Strategies:
- Random split (standard)
- Stratified split (imbalanced classes)
- Time-based split (temporal data)
- Group split (prevent data leakage)
- K-fold cross-validation
3. Model Selection
Algorithm Selection Guide:
| Data Size | Problem | Recommended Models |
|---|---|---|
| Small (<10K) | Classification | Logistic Regression, SVM, Random Forest |
| Small (<10K) | Regression | Linear Regression, Ridge, SVR |
| Medium (10K-1M) | Classification | XGBoost, LightGBM, Neural Networks |
| Medium (10K-1M) | Regression | XGBoost, LightGBM, Neural Networks |
| Large (>1M) | Any | Deep Learning, Distributed training |
| Tabular | Any | Gradient Boosting (XGBoost, LightGBM, CatBoost) |
| Images | Classification | CNN, ResNet, EfficientNet, Vision Transformers |
| Text | NLP | Transformers (BERT, RoBERTa, GPT) |
| Sequential | Time Series | LSTM, Transformer, Prophet |
4. Model Training
Hyperparameter Tuning:
- Grid Search: exhaustive, good for small spaces
- Random Search: efficient, good for large spaces
- Bayesian Optimization: smart exploration (Optuna, Hyperopt)
- Early stopping: prevent overfitting
Common Hyperparameters:
| Model | Key Parameters |
|---|---|
| XGBoost | learning_rate, max_depth, n_estimators, subsample |
| LightGBM | num_leaves, learning_rate, n_estimators, feature_fraction |
| Random Forest | n_estimators, max_depth, min_samples_split |
| Neural Networks | learning_rate, batch_size, layers, dropout |
5. Model Evaluation
Evaluation Best Practices:
- Always use held-out test set for final evaluation
- Use cross-validation during development
- Check for overfitting (train vs validation gap)
- Evaluate on multiple metrics
- Analyze errors qualitatively
Handling Imbalanced Data:
- Resampling: SMOTE, undersampling
- Class weights: weighted loss functions
- Threshold tuning: optimize decision threshold
- Evaluation: use PR-AUC over ROC-AUC
6. Production Deployment
Model Serving Patterns:
- REST API (Flask, FastAPI, TF Serving)
- Batch inference (scheduled jobs)
- Streaming (real-time predictions)
- Edge deployment (mobile, IoT)
Production Considerations:
- Latency requirements (p50, p95, p99)
- Throughput (requests per second)
- Model size and memory footprint
- Fallback strategies
- A/B testing framework
7. Monitoring & Maintenance
What to Monitor:
- Prediction latency
- Input feature distributions (data drift)
- Prediction distributions (concept drift)
- Model performance metrics
- Error rates and types
Retraining Triggers:
- Performance degradation below threshold
- Significant data drift detected
- Scheduled retraining (daily, weekly)
- New training data available
MLOps Best Practices
Experiment Tracking
Track for every experiment:
- Code version (git commit)
- Data version (hash or version ID)
- Hyperparameters
- Metrics (train, validation, test)
- Model artifacts
- Environment (packages, versions)
Model Versioning
models/
├── model_v1.0.0/
│ ├── model.pkl
│ ├── metadata.json
│ ├── requirements.txt
│ └── metrics.json
├── model_v1.1.0/
└── model_v2.0.0/CI/CD for ML
1. Continuous Integration:
- Data validation tests
- Model training tests
- Performance regression tests
2. Continuous Deployment:
- Staging environment validation
- Shadow mode testing
- Gradual rollout (canary)
- Automatic rollback
Reference Files
For detailed patterns and code examples, load reference files as needed:
- `references/preprocessing.md` - Data preprocessing patterns and feature engineering techniques
- `references/model_patterns.md` - Model architecture patterns and implementation examples
- `references/evaluation.md` - Comprehensive evaluation strategies and metrics
Integration with Other Skills
- performance - For optimizing inference latency
- testing - For ML-specific testing patterns
- database-optimization - For feature store queries
- debugging - For model debugging and error analysis
Data Preprocessing Patterns
Missing Value Strategies
Numerical Features
# Simple imputation
df['col'].fillna(df['col'].median(), inplace=True)
# Model-based imputation
from sklearn.impute import KNNImputer
imputer = KNNImputer(n_neighbors=5)
df_imputed = imputer.fit_transform(df)Categorical Features
# Mode imputation
df['col'].fillna(df['col'].mode()[0], inplace=True)
# New category for missing
df['col'].fillna('MISSING', inplace=True)Feature Scaling
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
# Standard scaling (mean=0, std=1) - use for most models
scaler = StandardScaler()
# MinMax scaling [0,1] - use for neural networks
scaler = MinMaxScaler()
# Robust scaling - use when outliers present
scaler = RobustScaler()
X_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)Categorical Encoding
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
import category_encoders as ce
# One-hot encoding (low cardinality)
encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
# Target encoding (high cardinality)
encoder = ce.TargetEncoder(cols=['category_col'])
# Frequency encoding
df['col_freq'] = df['col'].map(df['col'].value_counts(normalize=True))Feature Engineering Examples
Temporal Features
df['hour'] = df['timestamp'].dt.hour
df['day_of_week'] = df['timestamp'].dt.dayofweek
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
df['month'] = df['timestamp'].dt.month
# Cyclical encoding
df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24)
df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24)Numerical Transformations
# Log transform (right-skewed data)
df['col_log'] = np.log1p(df['col'])
# Box-Cox transform
from scipy.stats import boxcox
df['col_bc'], lambda_param = boxcox(df['col'] + 1)
# Polynomial features
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)Interaction Features
# Manual interactions
df['feature_interaction'] = df['feat1'] * df['feat2']
df['feature_ratio'] = df['feat1'] / (df['feat2'] + 1e-8)
# Automated interactions
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2, interaction_only=True)Outlier Handling
# IQR method
Q1 = df['col'].quantile(0.25)
Q3 = df['col'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
df_clean = df[(df['col'] >= lower_bound) & (df['col'] <= upper_bound)]
# Clipping
df['col_clipped'] = df['col'].clip(lower=lower_bound, upper=upper_bound)
# Z-score method
from scipy import stats
z_scores = np.abs(stats.zscore(df['col']))
df_clean = df[z_scores < 3]Data Leakage Prevention
Common Leakage Sources:
1. Future information in features 2. Target information in features 3. Train-test contamination during preprocessing
Prevention:
# Always fit on train, transform on test
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)
# Use pipelines
from sklearn.pipeline import Pipeline
pipeline = Pipeline([
('scaler', StandardScaler()),
('model', LogisticRegression())
])
pipeline.fit(X_train, y_train){
"schema_version": "2.0",
"meta": {
"generated_at": "2026-01-16T13:17:36.636Z",
"slug": "89jobrien-machine-learning",
"source_url": "https://github.com/89jobrien/steve/tree/main/steve/skills/machine-learning",
"source_ref": "main",
"model": "claude",
"analysis_version": "3.0.0",
"source_type": "community",
"content_hash": "0d45a3b3720fbc923d62041401f7ce973b55d89faa31342eb79806b2941eb442",
"tree_hash": "17aa1734f047b488f15b708730449bc923b9a736ab8d7e2f4c2c0b341e17f72c"
},
"skill": {
"name": "machine-learning",
"description": "Machine learning development patterns, model training, evaluation, and deployment. Use when building ML pipelines, training models, feature engineering, model evaluation, or deploying ML systems to production.",
"summary": "Machine learning development patterns, model training, evaluation, and deployment. Use when building...",
"icon": "🧠",
"version": "1.0.1",
"author": "Joseph OBrien",
"license": "UNLICENSED",
"category": "data",
"tags": [
"machine-learning",
"model-training",
"data-science",
"mlops"
],
"supported_tools": [
"claude",
"codex",
"claude-code"
],
"risk_factors": [
"external_commands",
"network"
]
},
"security_audit": {
"risk_level": "safe",
"is_blocked": false,
"safe_to_publish": true,
"summary": "Pure documentation skill containing only markdown guidance for ML development. All static findings are FALSE POSITIVES: The 'external_commands' detections are Python variable names (X_train, X_test) that regex incorrectly matches as backticks; the 'C2 keywords' and 'weak cryptographic algorithm' detections are SHA256 content hash strings in metadata; the 'system reconnaissance' detections are standard ML monitoring references. No executable code, scripts, network calls, or command execution capabilities exist.",
"risk_factor_evidence": [
{
"factor": "external_commands",
"evidence": [
{
"file": "references/preprocessing.md",
"line_start": 17,
"line_end": 25
},
{
"file": "references/preprocessing.md",
"line_start": 25,
"line_end": 29
},
{
"file": "references/preprocessing.md",
"line_start": 29,
"line_end": 35
},
{
"file": "references/preprocessing.md",
"line_start": 35,
"line_end": 39
},
{
"file": "references/preprocessing.md",
"line_start": 39,
"line_end": 53
},
{
"file": "references/preprocessing.md",
"line_start": 53,
"line_end": 57
},
{
"file": "references/preprocessing.md",
"line_start": 57,
"line_end": 69
},
{
"file": "references/preprocessing.md",
"line_start": 69,
"line_end": 75
},
{
"file": "references/preprocessing.md",
"line_start": 75,
"line_end": 84
},
{
"file": "references/preprocessing.md",
"line_start": 84,
"line_end": 88
},
{
"file": "references/preprocessing.md",
"line_start": 88,
"line_end": 100
},
{
"file": "references/preprocessing.md",
"line_start": 100,
"line_end": 104
},
{
"file": "references/preprocessing.md",
"line_start": 104,
"line_end": 112
},
{
"file": "references/preprocessing.md",
"line_start": 112,
"line_end": 116
},
{
"file": "references/preprocessing.md",
"line_start": 116,
"line_end": 132
},
{
"file": "references/preprocessing.md",
"line_start": 132,
"line_end": 144
},
{
"file": "references/preprocessing.md",
"line_start": 144,
"line_end": 157
},
{
"file": "SKILL.md",
"line_start": 178,
"line_end": 187
},
{
"file": "SKILL.md",
"line_start": 187,
"line_end": 206
},
{
"file": "SKILL.md",
"line_start": 206,
"line_end": 207
},
{
"file": "SKILL.md",
"line_start": 207,
"line_end": 208
}
]
},
{
"factor": "network",
"evidence": [
{
"file": "skill-report.json",
"line_start": 6,
"line_end": 6
}
]
}
],
"critical_findings": [],
"high_findings": [],
"medium_findings": [],
"low_findings": [],
"dangerous_patterns": [],
"files_scanned": 3,
"total_lines": 564,
"audit_model": "claude",
"audited_at": "2026-01-16T13:17:36.636Z"
},
"content": {
"user_title": "Apply ML Development Best Practices",
"value_statement": "Building machine learning systems requires navigating complex choices from data preprocessing to production deployment. This skill provides battle-tested patterns for the complete ML lifecycle.",
"seo_keywords": [
"machine learning",
"ML development",
"model training",
"feature engineering",
"MLOps",
"Claude",
"Codex",
"Claude Code",
"data preprocessing",
"model evaluation"
],
"actual_capabilities": [
"Guide ML problem definition and metric selection",
"Provide data preprocessing and feature engineering patterns",
"Recommend model selection based on data characteristics",
"Explain hyperparameter tuning strategies",
"Outline production deployment patterns and monitoring",
"Share MLOps best practices for experiment tracking"
],
"limitations": [
"Does not execute code or interact with ML frameworks directly",
"Does not provide custom model implementations or trained weights",
"Cannot access external data sources or APIs",
"Does not replace domain expertise for specific use cases"
],
"use_cases": [
{
"target_user": "Data scientists",
"title": "Structure ML Projects",
"description": "Follow proven patterns from data prep through model deployment"
},
{
"target_user": "ML Engineers",
"title": "Deploy Models to Production",
"description": "Learn serving patterns, monitoring strategies, and maintenance schedules"
},
{
"target_user": "Software Engineers",
"title": "Add ML to Applications",
"description": "Integrate ML capabilities using REST APIs and batch inference"
}
],
"prompt_templates": [
{
"title": "Problem Definition",
"scenario": "Start new ML project",
"prompt": "Help me define the right ML problem type and success metrics for [use case description]."
},
{
"title": "Data Preprocessing",
"scenario": "Prepare data for training",
"prompt": "What are the best practices for preprocessing [data type] with [specific challenges]?"
},
{
"title": "Model Selection",
"scenario": "Choose algorithms",
"prompt": "Recommend appropriate models for [data size] records with [problem type]. Explain trade-offs."
},
{
"title": "Production Deployment",
"scenario": "Deploy trained model",
"prompt": "What deployment patterns work best for [use case] with requirements: [latency, throughput]?"
}
],
"output_examples": [
{
"input": "Help me build a spam classifier with 10K labeled emails",
"output": [
"Problem type: Binary classification",
"Recommended metrics: AUC-ROC (primary), F1 (secondary)",
"Good starting models: Logistic Regression, Random Forest, or SVM",
"For 10K samples, use stratified split to maintain class balance",
"Consider TF-IDF or transformer embeddings for text features",
"Apply SMOTE if class imbalance exceeds 10:1 ratio"
]
},
{
"input": "What preprocessing steps do I need for customer churn prediction with tabular data?",
"output": [
"Missing values: Use median imputation for numerical, mode for categorical",
"Scaling: Apply StandardScaler, fit on train only",
"Encoding: One-hot for low cardinality, target encoding for high cardinality",
"Leakage check: Ensure no future information in features",
"Validation: Use stratified split due to likely class imbalance"
]
}
],
"best_practices": [
"Always use held-out test sets for final evaluation after validating on cross-validation",
"Fit preprocessing on training data only, then transform test data to prevent leakage",
"Track experiments with version control for code, data, and model artifacts"
],
"anti_patterns": [
"Using accuracy alone for imbalanced classification problems",
"Fitting preprocessing steps on the entire dataset before splitting",
"Deploying models without monitoring for data drift and performance degradation"
],
"faq": [
{
"question": "What ML frameworks does this skill support?",
"answer": "Framework-agnostic guidance applicable to scikit-learn, TensorFlow, PyTorch, XGBoost, and similar libraries."
},
{
"question": "What data sizes can Claude handle with this skill?",
"answer": "The skill provides guidance for small, medium, and large datasets with appropriate algorithm recommendations."
},
{
"question": "How does this skill integrate with other skills?",
"answer": "Works with performance, testing, database-optimization, and debugging skills for complete ML workflows."
},
{
"question": "Is my data safe when using this skill?",
"answer": "Yes. This skill only provides guidance patterns. No data is stored, transmitted, or processed externally."
},
{
"question": "Why is my model performing poorly on new data?",
"answer": "Common causes include data leakage, overfitting, and distribution shift between training and production data."
},
{
"question": "How does this compare to AutoML tools?",
"answer": "This skill explains concepts and patterns. AutoML automates selection. Understanding both approaches together is most effective."
}
]
},
"file_structure": [
{
"name": "references",
"type": "dir",
"path": "references",
"children": [
{
"name": "preprocessing.md",
"type": "file",
"path": "references/preprocessing.md",
"lines": 158
}
]
},
{
"name": "SKILL.md",
"type": "file",
"path": "SKILL.md",
"lines": 216
}
]
}