Feature Engineer

A standardized feature engineering skill. Same logic, every dataset, fully traceable.

When to use this skill

Activate when the user has a clean-ish tabular dataset and wants to make it model-ready. Typical signals:

• "Prepare these features for a model"
• "Encode my categorical variables"
• "Build a feature pipeline"
• "I want to train a model on this — what should I do first?"
• "Fais du feature engineering" / "encode mes variables"

Pre-condition: the data should already be reasonably clean. If you see > 30% missing in many columns or obvious quality issues, call `eda-explorer` first and tell the user to clean before feature engineering.

Do NOT activate this skill for:

• Initial exploration (use eda-explorer)
• Time-series-specific features (lags, rolling windows) — wait for time-series-features skill
• Text NLP feature extraction (out of scope)

Workflow

For every dataset, follow these 5 phases in order:

Phase 1 — Type detection

Auto-classify each column into one of:

• numeric (int, float, bool)
• categorical_low_card (object, < 10 unique values)
• categorical_high_card (object, 10–50 unique values)
• categorical_very_high_card (object, > 50 unique values)
• datetime
• id_or_constant (drop these — n_unique == n_rows or n_unique == 1)
• text (object with average string length > 30 chars — out of scope, drop with warning)

Print the classification table to the user before proceeding.

Phase 2 — Strategy selection

For each column type, apply the default strategy:

Override the default only if the user has specified a different strategy.

Phase 3 — Build the pipeline

Use sklearn.compose.ColumnTransformer + Pipeline. Never hand-roll transformations.

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, RobustScaler, OneHotEncoder
from sklearn.impute import SimpleImputer

numeric_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),  # or RobustScaler
])

cat_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", min_frequency=0.01)),
])

preprocessor = ColumnTransformer([
    ("num", numeric_pipe, numeric_cols),
    ("cat", cat_pipe, categorical_cols),
    ("date", datetime_decomposer, datetime_cols),
], remainder="drop")

Phase 4 — Fit, transform, validate

• Fit on the input data (or train split if user provides y)
• Transform and check:
• Output shape is consistent
• No NaN in output
• No infinite values
• Feature names are extractable via get_feature_names_out()

Phase 5 — Export artifacts

Save three files in outputs/features/:

1. pipeline.pkl — the fitted ColumnTransformer (joblib)
2. feature_dict.json — a feature dictionary (see schema below)
3. transformed_features.parquet — the transformed matrix

Feature Dictionary Schema

The JSON dictionary must follow this exact schema. It serves as auditable metadata.

{
  "skill_version": "0.1.0",
  "generated_at": "2026-04-27T14:32:11Z",
  "source_shape": [2000, 12],
  "output_shape": [2000, 47],
  "features": [
    {
      "name": "age_scaled",
      "source_column": "age",
      "transform": "StandardScaler",
      "params": {"mean": 42.3, "std": 14.1},
      "type": "numeric",
      "n_missing_before": 18,
      "imputation": "median=42.0"
    },
    {
      "name": "region_NORTH",
      "source_column": "region",
      "transform": "OneHotEncoder",
      "params": {"category": "NORTH"},
      "type": "categorical",
      "n_missing_before": 0
    }
  ],
  "dropped_columns": [
    {"name": "customer_id", "reason": "id_or_constant"},
    {"name": "free_text_notes", "reason": "text_out_of_scope"}
  ]
}

Output format

After execution, respond with:

# Feature Engineering Report

## Type Classification
| Column | Detected Type | Strategy |
|---|---|---|
...

## Pipeline Built
Steps: <list>
Input shape: (X, Y)
Output shape: (X, Z)

## Validation
- ✅ No NaN in output
- ✅ No infinite values
- ✅ Feature names extractable
- ⚠️ <any warnings>

## Artifacts Exported
- `outputs/features/pipeline.pkl` (Z KB)
- `outputs/features/feature_dict.json` (Z KB)
- `outputs/features/transformed_features.parquet` (Z KB)

## Next Steps
1. Train a baseline model with: `pd.read_parquet('outputs/features/transformed_features.parquet')`
2. Reload pipeline for inference: `joblib.load('outputs/features/pipeline.pkl')`
3. ...

Constraints

• Always use scikit-learn Pipeline + ColumnTransformer — never hand-roll
• Never apply target encoding without an explicit y from the user (data leakage risk)
• Always export the feature dictionary — it's the deliverable that makes this auditable
• Always print the classification table before transforming, so the user can override
• If the user has both train and test data, fit only on train, transform both
• Output language: match the user's language (FR or EN)