Shift e variabili ritardate
Crei colonne lag e lead con shift(), calcoli la variazione tra periodi con diff() e determini la variazione percentuale.
Shift e variabili ritardate è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Perché le variabili ritardate sono importanti
Nell'analisi delle serie temporali, il valore del periodo precedente (un ritardo) è spesso uno dei migliori predittori del valore attuale. Ad esempio, le vendite di ieri forniscono informazioni utili sulle vendite di oggi. La creazione di colonne con valori ritardati consente di usare i valori storici come caratteristiche nei modelli di machine learning o nell'analisi statistica dell'autocorrelazione. Pandas fornisce shift() per creare variabili ritardate con un'unica chiamata vettorializzata.
shift(): spostare i valori in avanti o all'indietro
Series.shift(n) sposta tutti i valori verso il basso di n posizioni (un valore positivo di n crea un ritardo), riempiendo le prime n righe con NaN. Passando un valore negativo di n, sposta i valori verso l'alto (crea un anticipo, riportando i valori futuri alla riga corrente). L'indice rimane invariato: vengono spostati solo i valori.
import pandas as pd
import numpy as np
df = pd.DataFrame(
{'sales': [100, 120, 115, 130, 140, 125]},
index=pd.date_range('2024-01-01', periods=6, freq='D')
)
# Lag-1: yesterday's sales
df['sales_lag1'] = df['sales'].shift(1)
# Lead-1: tomorrow's sales (shifted up)
df['sales_lead1'] = df['sales'].shift(-1)
print(df)Creazione di più colonne lag
In genere, per il machine learning si creano contemporaneamente diverse feature lag: lag-1, lag-7 (lo stesso giorno della settimana precedente) e lag-30 (lo stesso giorno del mese precedente). Il modo più leggibile consiste nel crearle in un ciclo e assegnare ciascuna a una nuova colonna. Il DataFrame risultante contiene la serie originale e tutte le relative versioni ritardate, pronte per la modellazione.
for lag in [1, 2, 3, 7]:
df[f'sales_lag{lag}'] = df['sales'].shift(lag)
print(df.columns.tolist())
# ['sales', 'sales_lag1', 'sales_lag2', 'sales_lag3', 'sales_lag7']
# Drop rows with NaN from the largest lag period
df_model = df.dropna()
print('Ready for modelling, shape:', df_model.shape)shift() con freq per lo scorrimento basato sul tempo
Anziché spostare i dati di un numero intero di righe, è possibile spostarli in base a un intervallo temporale usando il parametro freq. df.shift(1, freq='ME') sposta l'indice in avanti di una fine mese, lasciando invariati i valori ma modificando l'indice. È utile per allineare due serie temporali sfalsate di un intervallo fisso senza riordinare i valori.
monthly = pd.Series(
[100, 120, 115],
index=pd.date_range('2024-01-31', periods=3, freq='ME')
)
# Shift the index forward by 1 month (values stay, index moves)
shifted_index = monthly.shift(1, freq='ME')
print('Original index:', monthly.index.tolist())
print('Shifted index: ', shifted_index.index.tolist())
# Original: [2024-01-31, 2024-02-29, 2024-03-31]
# Shifted: [2024-02-29, 2024-03-31, 2024-04-30]diff(): variazione tra periodi
Series.diff(n) calcola la differenza tra un valore e quello che si trova n posizioni prima: x[t] - x[t-n]. Viene comunemente usato per calcolare le variazioni giorno su giorno, le differenze settimana su settimana o le variazioni anno su anno. Le prime n righe contengono NaN, perché non esistono valori precedenti da sottrarre.
df['sales_diff1'] = df['sales'].diff(1) # day-over-day change
df['sales_diff7'] = df['sales'].diff(7) # week-over-week change
print(df[['sales', 'sales_diff1']].head())
# sales sales_diff1
# 2024-01-01 100 NaN
# 2024-01-02 120 20.0 <- +20 from yesterday
# 2024-01-03 115 -5.0 <- -5 from yesterdaypct_change(): variazione percentuale
Series.pct_change(n) calcola la variazione percentuale relativa: (x[t] - x[t-n]) / x[t-n]. È essenziale per l'analisi finanziaria (rendimenti giornalieri), il calcolo dei tassi di crescita e tutte le situazioni in cui la variazione assoluta è meno significativa di quella relativa. Moltiplichi il risultato per 100 per ottenere la variazione percentuale.
df['pct_chg'] = df['sales'].pct_change().round(3)
df['pct_chg_7d'] = df['sales'].pct_change(7).round(3)
print(df[['sales', 'pct_chg']].head())
# sales pct_chg
# 2024-01-01 100 NaN
# 2024-01-02 120 0.200 <- 20% increase
# 2024-01-03 115 -0.042 <- 4.2% decreaseCombinare shift() con le operazioni aritmetiche
È possibile combinare shift() con le operazioni aritmetiche per calcolare feature temporali derivate. Ad esempio: il rapporto tra il valore odierno e quello della settimana precedente, la somma cumulativa a partire da un inizio stabilito o la differenza rispetto al valore di un anno prima. Tutti questi casi seguono lo stesso schema: si sposta la serie originale e si eseguono operazioni aritmetiche elemento per elemento con i valori correnti.
# Week-over-week growth index (today / last week)
df['wow_ratio'] = (df['sales'] / df['sales'].shift(7)).round(3)
# Deviation from 3-day lag
df['dev_3d'] = df['sales'] - df['sales'].shift(3)
# Is today higher than yesterday? (boolean feature)
df['higher_than_yesterday'] = df['sales'] > df['sales'].shift(1)
print(df[['sales', 'wow_ratio', 'higher_than_yesterday']].head())cumsum() e cumprod() per le feature cumulative
Series.cumsum() calcola il totale progressivo dalla prima riga fino a ciascuna riga, mentre Series.cumprod() calcola il prodotto cumulativo. Sono utili per i ricavi cumulativi, i rendimenti cumulativi (crescita composta) e i totali da inizio anno. Non richiedono argomenti e funzionano con qualsiasi Series numerica o colonna numerica di un DataFrame.
# Cumulative sales (year-to-date total)
df['ytd_sales'] = df['sales'].cumsum()
# Cumulative product: compound growth factor
returns = pd.Series([0.02, -0.01, 0.03, 0.01, -0.005])
df_ret = pd.DataFrame({'daily_return': returns})
df_ret['compound'] = (1 + df_ret['daily_return']).cumprod() - 1
print(df_ret)Feature lag per il machine learning
Quando prepara dati di serie temporali per il machine learning, un passaggio standard di feature engineering consiste nel creare una matrice di feature lag. Ogni colonna rappresenta la variabile obiettivo in un diverso istante passato. Dopo aver creato i lag, elimini le righe contenenti NaN (che compaiono all'inizio perché manca lo storico) e suddivida i dati in set di addestramento e di test senza mescolarli, rispettando l'ordine temporale.
def make_lag_matrix(series, n_lags):
df_lags = pd.DataFrame({'y': series})
for lag in range(1, n_lags + 1):
df_lags[f'lag_{lag}'] = series.shift(lag)
return df_lags.dropna()
lag_df = make_lag_matrix(df['sales'], n_lags=3)
print(lag_df)
# y lag_1 lag_2 lag_3
# ... ... ... ...Spostamento all'interno dei gruppi
Quando i dati contengono più entità (ad esempio più prodotti o aree geografiche in un unico DataFrame), deve calcolare gli spostamenti all'interno di ciascun gruppo di entità, separatamente. Usi groupby().shift() per assicurarsi che il lag della prima riga del prodotto A sia NaN e non l'ultimo valore del prodotto B. Mescolare i gruppi senza questo passaggio è un errore comune e subdolo di data leakage.
df_multi = pd.DataFrame({
'product': ['A', 'A', 'A', 'B', 'B', 'B'],
'sales': [100, 120, 115, 200, 210, 195]
})
# WRONG: lag crosses product boundary
df_multi['lag_wrong'] = df_multi['sales'].shift(1)
# CORRECT: lag within each product
df_multi['lag_correct'] = df_multi.groupby('product')['sales'].shift(1)
print(df_multi)Interpretare i segni di pct_change
Un valore positivo di pct_change() indica che il valore corrente è maggiore di quello precedente; un valore negativo indica che è minore. Presti attenzione alla divisione per zero quando il valore precedente è zero: il risultato è NaN o inf, a seconda del segno del valore corrente. Usi replace([float('inf'), float('-inf')], float('nan')) per eliminare i valori infiniti dopo pct_change().
import numpy as np
s = pd.Series([0, 100, 50, 200])
chg = s.pct_change()
print(chg)
# 0 NaN <- no prior value
# 1 inf <- 0 -> 100 (division by zero)
# 2 -0.5 <- 100 -> 50 (-50%)
# 3 3.0 <- 50 -> 200 (+300%)
# Clean infinite values
chg_clean = chg.replace([float('inf'), float('-inf')], float('nan'))
print(chg_clean)Verifica rapida
Verifichi la Sua comprensione dello spostamento dei dati e delle feature lag affrontati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che shift(n) crea feature lag spostando i valori verso il basso di n posizioni; diff(n) calcola la variazione assoluta tra periodi; pct_change(n) calcola la variazione percentuale relativa; e, quando lavora con più gruppi, deve usare groupby().shift() per evitare il data leakage. Ora estrarremo le feature temporali usando l'accessor .dt.
Domande Frequenti
La lezione «Shift e variabili ritardate» è gratuita?
Sì — il testo completo di «Shift e variabili ritardate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Cosa imparerò in «Shift e variabili ritardate»?
Crei colonne lag e lead con shift(), calcoli la variazione tra periodi con diff() e determini la variazione percentuale. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?
Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Shift e variabili ritardate»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?
Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- DatetimeIndex e intervalli di periodi
- Ricampionare serie temporali
- Shift e variabili ritardate
- Estrarre caratteristiche temporali