Il feature engineering interview rappresenta uno degli scogli più impegnativi nei processi di selezione per ruoli di data science e machine learning nel 2026. La capacità di trasformare dati grezzi in feature significative distingue un modello mediocre da uno ad alte prestazioni, e i recruiter lo sanno bene. Questa guida approfondisce le tecniche fondamentali di feature engineering, accompagnate da codice Python pronto all'uso e dalle domande più frequenti nei colloqui tecnici.

Suggerimento

Durante un colloquio di data science, non basta conoscere gli algoritmi: i selezionatori valutano la capacità di ragionare sulla qualità dei dati in ingresso. Prepararsi sul machine learning feature engineering significa dimostrare padronanza dell'intero pipeline, dalla raccolta dati al deployment.

Cos'è il Feature Engineering e Perché è Decisivo

Il feature engineering è il processo di creazione, trasformazione e selezione delle variabili (feature) che alimentano un modello di machine learning. Secondo un'analisi di Kaggle sulle competizioni vinte tra il 2020 e il 2025, oltre il 70% dei modelli vincitori deve il proprio vantaggio competitivo non all'architettura del modello, ma alla qualità delle feature.

Nel contesto delle data science interview questions, il feature engineering compare in quasi ogni colloquio tecnico. Le aziende cercano professionisti capaci di:

Identificare quali variabili grezze contengono segnale predittivo
Trasformare dati non strutturati in rappresentazioni numeriche utilizzabili
Ridurre la dimensionalità senza perdere informazione critica
Gestire dati mancanti, outlier e distribuzioni anomale

La differenza tra un candidato junior e uno senior si manifesta proprio nella profondità con cui vengono affrontate queste trasformazioni.

Scaling e Normalizzazione delle Feature

La maggior parte degli algoritmi di machine learning è sensibile alla scala delle variabili in input. Un modello di regressione logistica o una SVM possono produrre risultati distorti se una feature varia tra 0 e 1 mentre un'altra oscilla tra 1.000 e 1.000.000. Lo scaling risolve questo problema portando tutte le feature su una scala comparabile.

python

# feature_scaling.py
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

df = pd.DataFrame({
    'salary': [35000, 72000, 120000, 45000, 88000],
    'years_exp': [2, 5, 12, 3, 7],
    'satisfaction_score': [3.2, 4.1, 4.8, 2.9, 3.7]
})

# StandardScaler: media 0, deviazione standard 1
standard_scaler = StandardScaler()
df_standard = pd.DataFrame(
    standard_scaler.fit_transform(df),
    columns=df.columns
)

# MinMaxScaler: valori compresi tra 0 e 1
minmax_scaler = MinMaxScaler()
df_minmax = pd.DataFrame(
    minmax_scaler.fit_transform(df),
    columns=df.columns
)

# RobustScaler: resistente agli outlier, usa mediana e IQR
robust_scaler = RobustScaler()
df_robust = pd.DataFrame(
    robust_scaler.fit_transform(df),
    columns=df.columns
)

print("Standard Scaling:\n", df_standard.head())
print("\nMinMax Scaling:\n", df_minmax.head())
print("\nRobust Scaling:\n", df_robust.head())

Una domanda tipica da colloquio chiede di spiegare quando preferire RobustScaler rispetto a StandardScaler. La risposta corretta: quando il dataset contiene outlier significativi, poiché RobustScaler utilizza mediana e intervallo interquartile anziché media e deviazione standard, risultando meno influenzato da valori estremi.

Encoding delle Variabili Categoriche

Le variabili categoriche richiedono una trasformazione numerica prima di essere processate dalla maggior parte degli algoritmi. La scelta della tecnica di encoding influenza direttamente le prestazioni del modello e rappresenta un tema ricorrente nelle data science interview questions.

python

# categorical_encoding.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
from category_encoders import TargetEncoder

df = pd.DataFrame({
    'city': ['Milano', 'Roma', 'Napoli', 'Milano', 'Roma', 'Torino'],
    'education': ['laurea', 'master', 'diploma', 'master', 'laurea', 'diploma'],
    'department': ['engineering', 'sales', 'engineering', 'hr', 'sales', 'engineering'],
    'hired': [1, 0, 1, 1, 0, 1]
})

# One-Hot Encoding: per variabili nominali a bassa cardinalità
df_onehot = pd.get_dummies(df, columns=['city', 'department'], drop_first=True)

# Ordinal Encoding: per variabili con ordine naturale
education_order = [['diploma', 'laurea', 'master']]
ordinal_enc = OrdinalEncoder(categories=education_order)
df['education_ordinal'] = ordinal_enc.fit_transform(df[['education']])

# Target Encoding: per variabili ad alta cardinalità
target_enc = TargetEncoder(cols=['city'], smoothing=1.0)
df['city_target_enc'] = target_enc.fit_transform(df['city'], df['hired'])

print("One-Hot Encoded:\n", df_onehot.head())
print("\nOrdinal + Target Encoding:\n", df[['city', 'education_ordinal', 'city_target_enc']].head())

Un errore comune nei colloqui è proporre one-hot encoding per variabili con centinaia di categorie. Il target encoding o l'embedding encoding rappresentano alternative più efficienti in questi casi, evitando l'esplosione dimensionale.

Tecniche di Feature Selection

Le feature selection techniques consentono di identificare le variabili più rilevanti, eliminando rumore e riducendo il rischio di overfitting. Esistono tre famiglie principali: metodi filter, wrapper e embedded.

python

# feature_selection.py
import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    mutual_info_classif,
    SelectKBest,
    f_classif,
    RFE
)
from sklearn.ensemble import RandomForestClassifier

# Dataset sintetico con 20 feature, di cui 10 informative
X, y = make_classification(
    n_samples=1000, n_features=20, n_informative=10,
    n_redundant=5, random_state=42
)
feature_names = [f'feature_{i}' for i in range(20)]
df = pd.DataFrame(X, columns=feature_names)

# 1. Filter Method: Mutual Information
mi_scores = mutual_info_classif(X, y, random_state=42)
mi_ranking = pd.Series(mi_scores, index=feature_names).sort_values(ascending=False)
print("Top 10 feature per Mutual Information:\n", mi_ranking.head(10))

# 2. Filter Method: ANOVA F-test
selector_kbest = SelectKBest(score_func=f_classif, k=10)
X_selected = selector_kbest.fit_transform(X, y)
selected_mask = selector_kbest.get_support()
print("\nFeature selezionate (ANOVA):", np.array(feature_names)[selected_mask])

# 3. Wrapper Method: Recursive Feature Elimination
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(estimator=rf, n_features_to_select=10, step=1)
rfe.fit(X, y)
print("\nFeature selezionate (RFE):", np.array(feature_names)[rfe.support_])

# 4. Embedded Method: Feature Importance da Random Forest
rf.fit(X, y)
importances = pd.Series(rf.feature_importances_, index=feature_names)
print("\nTop 10 feature per importanza RF:\n", importances.sort_values(ascending=False).head(10))

Nei colloqui viene spesso chiesto di confrontare vantaggi e svantaggi di ciascun approccio. I metodi filter sono rapidi ma non considerano le interazioni tra feature. I wrapper sono più accurati ma computazionalmente costosi. I metodi embedded offrono un buon compromesso, integrando la selezione nel processo di addestramento.

Pronto a superare i tuoi colloqui su Data Science & ML?

Pratica con i nostri simulatori interattivi, flashcards e test tecnici.

Esplora Data Science & ML

Creazione di Feature di Interazione

Le feature di interazione catturano relazioni non lineari tra variabili che un modello lineare non riesce a cogliere autonomamente. Questa tecnica di machine learning feature engineering può migliorare significativamente le prestazioni predittive.

python

# interaction_features.py
import pandas as pd
import numpy as np
from sklearn.preprocessing import PolynomialFeatures

df = pd.DataFrame({
    'area_mq': [60, 85, 120, 45, 200],
    'num_rooms': [2, 3, 4, 1, 5],
    'floor': [3, 7, 1, 10, 2],
    'distance_center_km': [2.5, 5.0, 12.0, 1.0, 8.0],
    'price': [280000, 350000, 310000, 320000, 450000]
})

# Feature manuali basate su domain knowledge
df['price_per_mq'] = df['price'] / df['area_mq']
df['area_per_room'] = df['area_mq'] / df['num_rooms']
df['density_score'] = df['num_rooms'] / df['area_mq'] * 100
df['accessibility_index'] = df['floor'] * df['distance_center_km']

# Feature polinomiali automatiche (grado 2)
poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
feature_cols = ['area_mq', 'num_rooms', 'floor', 'distance_center_km']
X_poly = poly.fit_transform(df[feature_cols])
poly_names = poly.get_feature_names_out(feature_cols)

df_poly = pd.DataFrame(X_poly, columns=poly_names)
print("Feature di interazione generate:\n", df_poly.head())
print(f"\nNumero feature originali: {len(feature_cols)}")
print(f"Numero feature dopo interazione: {X_poly.shape[1]}")

Un aspetto critico da evidenziare in un feature engineering interview: le feature di interazione polinomiali crescono esponenzialmente con il numero di variabili. Con 50 feature e grado 2, si ottengono oltre 1.300 nuove variabili. La selezione successiva diventa quindi imprescindibile.

Gestione dei Valori Mancanti

La gestione dei missing values è una competenza fondamentale valutata in ogni colloquio di data science. Le strategie variano dalla semplice imputazione statistica a tecniche avanzate basate su modelli predittivi.

python

# missing_values.py
import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

np.random.seed(42)
df = pd.DataFrame({
    'age': [25, np.nan, 35, 42, np.nan, 28, 55, np.nan, 31, 47],
    'income': [30000, 45000, np.nan, 72000, 55000, np.nan, 90000, 40000, np.nan, 68000],
    'score': [7.2, 8.1, np.nan, 6.5, 7.8, 8.5, np.nan, 7.0, 8.3, 6.9],
    'category': ['A', 'B', 'A', np.nan, 'B', 'C', 'A', np.nan, 'B', 'C']
})

# Analisi dei pattern di missing
print("Percentuale missing per colonna:")
print(df.isnull().mean() * 100)

# 1. Feature indicatore di missing (preserva l'informazione)
for col in ['age', 'income', 'score']:
    df[f'{col}_is_missing'] = df[col].isnull().astype(int)

# 2. Imputazione con mediana (variabili numeriche)
median_imputer = SimpleImputer(strategy='median')
df[['age', 'income', 'score']] = median_imputer.fit_transform(
    df[['age', 'income', 'score']]
)

# 3. Imputazione con moda (variabili categoriche)
mode_imputer = SimpleImputer(strategy='most_frequent')
df[['category']] = mode_imputer.fit_transform(df[['category']])

# 4. KNN Imputer: considera la similarità tra osservazioni
knn_imputer = KNNImputer(n_neighbors=3)
# df_knn = pd.DataFrame(knn_imputer.fit_transform(df_numeric), columns=numeric_cols)

# 5. Iterative Imputer (MICE): imputazione multivariata
iterative_imputer = IterativeImputer(max_iter=10, random_state=42)
# df_iter = pd.DataFrame(iterative_imputer.fit_transform(df_numeric), columns=numeric_cols)

print("\nDataset dopo imputazione:\n", df.head())

La creazione di feature indicatore (_is_missing) prima dell'imputazione è una best practice spesso trascurata dai candidati. Il pattern di missing può contenere informazione predittiva: ad esempio, un campo "reddito" mancante potrebbe correlare con una specifica fascia demografica.

Feature Engineering Basato sul Tempo

Le serie temporali e i dati con componente temporale richiedono tecniche specifiche di feature engineering. Questo ambito è particolarmente rilevante per ruoli in fintech, e-commerce e ad-tech.

python

# time_features.py
import pandas as pd
import numpy as np

dates = pd.date_range('2025-01-01', periods=365, freq='D')
np.random.seed(42)

df = pd.DataFrame({
    'date': dates,
    'sales': np.random.poisson(lam=100, size=365) + np.sin(np.arange(365) * 2 * np.pi / 7) * 20,
    'visitors': np.random.poisson(lam=500, size=365)
})

# Feature temporali base
df['day_of_week'] = df['date'].dt.dayofweek
df['month'] = df['date'].dt.month
df['quarter'] = df['date'].dt.quarter
df['is_weekend'] = (df['day_of_week'] >= 5).astype(int)
df['day_of_year'] = df['date'].dt.dayofyear
df['week_of_year'] = df['date'].dt.isocalendar().week.astype(int)

# Feature cicliche (preservano la continuità temporale)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
df['dow_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
df['dow_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)

# Lag features e rolling statistics
for lag in [1, 7, 14, 30]:
    df[f'sales_lag_{lag}'] = df['sales'].shift(lag)

for window in [7, 14, 30]:
    df[f'sales_rolling_mean_{window}'] = df['sales'].rolling(window=window).mean()
    df[f'sales_rolling_std_{window}'] = df['sales'].rolling(window=window).std()

# Tasso di variazione
df['sales_pct_change_7d'] = df['sales'].pct_change(periods=7)
df['conversion_rate'] = df['sales'] / df['visitors']

print("Feature temporali generate:\n", df.head(35))
print(f"\nNumero totale di feature: {len(df.columns)}")

L'encoding ciclico tramite seno e coseno è una tecnica avanzata che i selezionatori apprezzano particolarmente. Senza di essa, il modello non comprende che dicembre (12) è vicino a gennaio (1), trattandoli come estremi opposti di una scala lineare.

Domande Frequenti nei Colloqui 2026

Le data science interview questions sul feature engineering nel 2026 si concentrano su scenari pratici. Ecco le domande più ricorrenti e i punti chiave da trattare nella risposta:

"Come gestiresti una variabile categorica con 10.000 categorie?" Target encoding con regolarizzazione, embedding learning, oppure raggruppamento delle categorie a bassa frequenza in una categoria "other". Mai one-hot encoding.

"Quando il feature engineering è più importante della scelta del modello?" Quando i dati sono tabulari, il dataset è di dimensioni medie, e le relazioni tra variabili non sono catturabili da trasformazioni automatiche. I gradient boosted trees beneficiano enormemente di buone feature manuali.

"Come eviti il data leakage nel feature engineering?" Applicando tutte le trasformazioni (scaling, encoding, imputazione) esclusivamente sul training set e utilizzando i parametri appresi per trasformare validation e test set. Le rolling statistics devono usare solo dati passati.

"Quali feature selection techniques applichi prima di addestrare un modello?" Un approccio a tre fasi: rimozione delle feature a varianza zero, filtro basato su correlazione o mutual information, e infine selezione embedded tramite L1 regularization o feature importance.

Conclusione e Takeaway Operativi

Il machine learning feature engineering rimane la competenza più richiesta nei colloqui di data science del 2026. Per prepararsi efficacemente, conviene seguire un approccio strutturato:

Padroneggiare le basi: scaling, encoding e gestione dei missing values costituiscono il fondamento. Ogni tecnica ha casi d'uso specifici e un candidato preparato sa giustificare ogni scelta.
Pensare in termini di domain knowledge: le feature più potenti nascono dalla comprensione del problema di business, non dall'applicazione meccanica di trasformazioni.
Prevenire il data leakage: ogni trasformazione deve rispettare la separazione temporale e logica tra training e test set.
Automatizzare con criterio: strumenti come Featuretools o tsfresh accelerano il processo, ma la supervisione umana resta necessaria per validare la rilevanza delle feature generate.
Praticare su dataset reali: le competizioni Kaggle e i dataset pubblici offrono scenari ideali per affinare le proprie feature selection techniques sotto pressione.

La preparazione al feature engineering interview richiede pratica costante e la capacità di articolare il ragionamento dietro ogni decisione. Non si tratta solo di scrivere codice corretto, ma di dimostrare un pensiero critico applicato ai dati.

Inizia a praticare!

Metti alla prova le tue conoscenze con i nostri simulatori di colloquio e test tecnici.

Crea il mio account gratuito

Feature Engineering per Machine Learning: Tecniche e Domande da Colloquio 2026

Cos'è il Feature Engineering e Perché è Decisivo

Scaling e Normalizzazione delle Feature

Encoding delle Variabili Categoriche

Tecniche di Feature Selection

Pronto a superare i tuoi colloqui su Data Science & ML?

Creazione di Feature di Interazione

Gestione dei Valori Mancanti

Feature Engineering Basato sul Tempo

Domande Frequenti nei Colloqui 2026

Conclusione e Takeaway Operativi

Inizia a praticare!

Articoli correlati

Top 25 Domande di Colloquio per Data Scientist nel 2026

Algoritmi di Machine Learning Spiegati: Guida Completa per i Colloqui Tecnici

Python per la Data Science: NumPy, Pandas e Scikit-Learn nel 2026