Feature Engineering con Python — Trasforma Dati Grezzi in Modelli Performanti • Meteora Web Agency

Ti è mai capitato di passare ore a pulire un dataset, lanciare un modello, e ottenere un punteggio imbarazzante? Il problema non è quasi mai l’algoritmo. È come hai presentato i dati. Noi, di Meteora Web, lo vediamo ogni giorno nei progetti che ci arrivano: feature costruite a caso, scale incoerenti, valori mancanti gestiti con un banale drop. Il machine learning è matematica, non magia. La feature engineering è il ponte tra dati grezzi e segnali che un modello può sfruttare. Qui non ti diamo teoria astratta: ti mostriamo come trasformare colonne in leve di performance, con codice reale, esempi concreti e metriche alla mano.

Questa guida fa parte del nostro pillar su Machine Learning con Python — modelli pronti per il business, dove uniamo competenza tecnica e visione economica. Perché un feature engineering fatto bene costa tempo all’inizio, ma restituisce margini veri.

Perché la feature engineering è critica nel machine learning?

Un modello è un motore: se gli dai benzina sporca, si ingolfa. Le feature sono il carburante. Una variabile ben costruita può spostare l’R² di 0,1 o più. Il tempo speso qui non è un costo, è l’investimento più alto che puoi fare. In un nostro progetto per un cliente e-commerce, una feature che incrociava giorno della settimana e ora di acquisto ha portato un incremento del 15% sulla previsione delle vendite. L’algoritmo era lo stesso. I dati erano gli stessi. La differenza? Come li abbiamo impacchettati.

La feature engineering serve a:

Trasformare variabili non lineari in segnali lineari (es. log-transformation)
Ridurre il rumore (es. binning, smoothing)
Introdurre conoscenza di dominio (es. rapporto tra due variabili)
Permettere a modelli semplici di competere con quelli complessi

Come gestire i valori mancanti in modo efficace?

Buttare via righe con NaN è il lusso che nessuno può permettersi con dataset piccoli o costosi. Ma neppure riempire con la media va bene sempre. La scelta dipende dalla natura del dato e dal perché manca. Ecco tre strategie mirate.

Imputazione basata su distribuzione

Se i dati mancano in modo casuale (MCAR), puoi usare media o mediana. Ma se la distribuzione è asimmetrica, la mediana è più robusta. In Python:

import pandas as pd
import numpy as np

df['età'].fillna(df['età'].median(), inplace=True)

Imputazione per categoria

Se hai una variabile categoriale e una numerica con NaN, calcola la mediana per ogni gruppo:

df['reddito'] = df.groupby('regione')['reddito'].transform(lambda x: x.fillna(x.median()))

Feature missing indicator

Aggiungi una colonna binaria che indica dove i dati mancavano. Il modello può imparare che l’assenza stessa è un segnale:

df['età_missing'] = df['età'].isna().astype(int)
df['età'].fillna(df['età'].median(), inplace=True)

Perché conviene: recuperi righe che contengono comunque informazione sulle altre variabili, e dai al modello la possibilità di apprendere la relazione tra assenza e target.

Come codificare le variabili categoriali per ottenere le migliori performance?

One-hot encoding va bene per poche categorie. Ma con 50+ valori, esplode la dimensionalità. Le alternative esistono e funzionano.

Target encoding

Sostituisci ogni categoria con la media del target su quel gruppo. Attenzione: rischio overfitting. Usa un smoothing o una validazione incrociata. Ecco una versione semplice:

from sklearn.model_selection import KFold
import numpy as np

def target_encoding(df, feature, target, k=5):
    kf = KFold(n_splits=k, shuffle=True, random_state=42)
    encoded = np.empty(df.shape[0])
    for train_idx, val_idx in kf.split(df):
        X_train, X_val = df.iloc[train_idx], df.iloc[val_idx]
        means = X_train.groupby(feature)[target].mean()
        encoded[val_idx] = X_val[feature].map(means).values
    return encoded

Ordinal Encoding con ordine reale

Se le categorie hanno un ordinamento (es. 'basso', 'medio', 'alto'), mappa a numeri interi:

mappa_ordine = {'basso': 1, 'medio': 2, 'alto': 3}
df['priorità'] = df['priorità'].map(mappa_ordine)

Frequency encoding

Sostituisci ogni categoria con la sua frequenza. Utile per variabili ad alta cardinalità:

freq = df['codice_prodotto'].value_counts()
df['codice_prodotto_freq'] = df['codice_prodotto'].map(freq)

Come creare feature di interazione e polinomiali?

I modelli lineari non colgono interazioni tra variabili. Se sospetti che l'effetto combinato di età e reddito sia più della somma, devi crearlo esplicitamente.

Interazioni binarie

df['età_reddito'] = df['età'] * df['reddito']

Polinomiali con scikit-learn

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2, interaction_only=False, include_bias=False)
X_poly = poly.fit_transform(df[['età', 'reddito']])
# genera anche età², reddito², età*reddito

Attenzione: se hai molte feature, le polinomiali esplodono. Usale solo dove hai evidenza di non-linearità (EDA o conoscenza di dominio).

Come scalare e normalizzare le feature correttamente?

Algoritmi basati su distanze (SVM, k-NN, PCA) sono sensibili alla scala. Alberi decisionali no. Ma anche quando non serve per l’algoritmo, la scala può aiutare la convergenza (neural network) o la regolarizzazione.

Standardizzazione (Z-score)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
df_scaled = scaler.fit_transform(df[['età', 'reddito']])

Min-Max scaling

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
df_scaled = scaler.fit_transform(df[['età', 'reddito']])

Robust scaling

Resistente agli outlier: usa mediana e IQR:

from sklearn.preprocessing import RobustScaler

scaler = RobustScaler()
df_scaled = scaler.fit_transform(df[['età', 'reddito']])

Quando usare cosa: StandardScaler se i dati sono già normali. MinMax se hai bound fisici (es. percentuali). Robust se ci sono outlier che non vuoi amplificare.

Come sfruttare la conoscenza di dominio per creare feature ad alto impatto?

La differenza tra un data scientist e un ingegnere che sa di business è questa. Noi, di Meteora Web, veniamo dalla contabilità. Quando lavoriamo su un progetto di previsione vendite per un negozio di abbigliamento, non guardiamo solo le vendite passate. Costruiamo feature come: rapporto tra giacenza media e vendite, stagionalità basata su date di saldi reali, indicatori di rottura di stock. Ecco un esempio pratico:

# Feature: giorni dalla fine del saldo (effetto rimbalzo)
df['giorni_fine_saldi'] = (pd.to_datetime('2026-01-31') - df['data']).dt.days
df['fine_saldo'] = (df['giorni_fine_saldi'] >= 0) & (df['giorni_fine_saldi'] <= 30)

Perché conviene: una feature che incapsula un pattern di business vale più di mille variabili automatiche. Il modello impara da te, non solo dai numeri.

Come automatizzare la feature engineering con librerie come Feature-engine?

Dopo aver padroneggiato i manuali, l’automazione è un acceleratore. Feature-engine è una libreria Python che integra molte tecniche con interfaccia sklearn.

from feature_engine.encoding import TargetEncoder
from feature_engine.imputation import MeanMedianImputer
from feature_engine.creation import MathFeatures

# Pipeline
imp = MeanMedianImputer(imputation_method='median', variables=['età'])
enc = TargetEncoder(variables=['regione'])
math = MathFeatures(variables=['altezza', 'peso'], func=['ratio', 'product'])

from sklearn.pipeline import Pipeline
pipe = Pipeline([('imputer', imp), ('encoder', enc), ('math', math)])
df_transformed = pipe.fit_transform(df, df['target'])

Altre librerie utili: category_encoders per encoding avanzati (CatBoost, LeaveOneOut), tsfresh per time series, featuretools per deep feature synthesis.

Ricorda: l’automazione non sostituisce il ragionamento. Noi la usiamo per accelerare, ma ogni feature generata va validata con il business.

Cosa fare adesso

Hai gli strumenti. Ora mettili in pratica:

Analizza il tuo dataset: controlla missing, outlier, distribuzioni con pandas profiling o ydata-profiling.
Scegli una strategia di imputazione non banale: per ogni colonna valuta se usare mediana, media, o un modello predittivo.
Codifica le categoriali: se hai alta cardinalità, prova target encoding con cross-validation.
Crea almeno 3 feature di dominio: chiediti cosa sa il tuo business che il dataset non mostra esplicitamente.
Testa l’impatto: confronta le performance del modello con e senza le nuove feature. Documenta i miglioramenti.

E se vuoi un supporto concreto sul tuo progetto, contattaci. Noi di Meteora Web trasformiamo dati grezzi in vantaggio competitivo, dal 2017.