Pandas & NumPy Academy · Pelajaran

Anjakan dan Ciri Lengah

Cipta lajur lengah dan hadapan dengan shift(), kira perubahan antara tempoh dengan diff() dan hitung perubahan peratusan.

Pelajaran 3 daripada 413 langkah

Anjakan dan Ciri Lengah ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Mengapa Ciri Susulan Penting

Dalam analisis siri masa, nilai pada langkah masa sebelumnya (iaitu susulan) selalunya merupakan salah satu peramal terbaik bagi nilai semasa. Contohnya, jualan semalam memberikan maklumat tentang jualan hari ini. Mencipta lajur susulan membolehkan anda menggunakan nilai sejarah sebagai ciri dalam model pembelajaran mesin atau dalam analisis statistik autokorelasi. Pandas menyediakan shift() untuk mencipta ciri susulan dalam satu panggilan tervektor.

shift(): Mengalihkan Nilai ke Hadapan atau ke Belakang

Series.shift(n) mengalihkan semua nilai ke bawah sebanyak n kedudukan (n positif mencipta susulan), lalu mengisi n baris pertama dengan NaN. Nilai n negatif mengalihkan nilai ke atas (mencipta pendahulu, iaitu mengalihkan nilai masa hadapan kembali ke baris semasa). Indeks kekal tidak berubah — hanya nilai yang dialihkan.

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)

Mencipta Berbilang Lajur Ciri Tertangguh

Biasanya, anda mencipta beberapa ciri tertangguh serentak untuk pembelajaran mesin — lag-1, lag-7 (hari yang sama pada minggu lalu) dan lag-30 (hari yang sama pada bulan lalu). Cara yang paling mudah dibaca ialah menciptanya dalam gelung dan menetapkan setiap satunya kepada lajur baharu. DataFrame yang terhasil mengandungi siri asal serta semua versinya yang tertangguh, sedia untuk pemodelan.

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() dengan freq untuk Anjakan Berasaskan Masa

Daripada mengalihkan mengikut bilangan baris integer, anda boleh mengalihkan mengikut ofset masa menggunakan parameter freq. df.shift(1, freq='ME') mengalihkan indeks ke hadapan sebanyak satu hujung bulan, sambil mengekalkan nilai pada tempatnya tetapi mengubah indeks. Ini berguna untuk menjajarkan dua siri masa yang dianjak oleh tempoh masa tetap tanpa menyusun semula nilai.

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(): Perubahan antara Tempoh

Series.diff(n) mengira perbezaan antara sesuatu nilai dengan nilai n kedudukan sebelumnya: x[t] - x[t-n]. Ini lazimnya digunakan untuk mengira perubahan hari ke hari, perbezaan minggu ke minggu atau perubahan tahun ke tahun. n baris pertama ialah NaN kerana tiada nilai sebelumnya untuk ditolak.

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 yesterday

pct_change(): Perubahan Peratusan

Series.pct_change(n) mengira perubahan peratusan relatif: (x[t] - x[t-n]) / x[t-n]. Ini penting untuk analisis kewangan (pulangan harian), pengiraan kadar pertumbuhan dan apa-apa keadaan yang perubahan relatifnya lebih bermakna daripada perubahan mutlak. Darabkan dengan 100 untuk mendapatkan mata peratusan.

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% decrease

Menggabungkan shift() dengan Aritmetik

Anda boleh menggabungkan shift() dengan aritmetik untuk mengira ciri masa terbitan. Contohnya: nisbah nilai hari ini kepada nilai minggu lalu, jumlah terkumpul sejak permulaan yang ditetapkan atau perbezaan daripada nilai setahun lalu. Kesemuanya mengikut corak yang sama: alihkan siri asal dan lakukan aritmetik unsur demi unsur dengan nilai semasa.

# 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() dan cumprod() untuk Ciri Terkumpul

Series.cumsum() mengira jumlah berjalan dari baris pertama hingga setiap baris, manakala Series.cumprod() mengira hasil darab terkumpul. Ini berguna untuk hasil terkumpul, pulangan terkumpul (pertumbuhan berganda) dan jumlah dari awal tahun hingga kini. Kedua-duanya tidak memerlukan argumen dan berfungsi pada sebarang Series berangka atau lajur 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)

Ciri Tertangguh untuk Pembelajaran Mesin

Apabila menyediakan data siri masa untuk pembelajaran mesin, langkah kejuruteraan ciri yang standard ialah mencipta matriks ciri tertangguh. Setiap lajur mewakili pemboleh ubah sasaran pada langkah masa lampau yang berbeza. Selepas mencipta ciri tertangguh, gugurkan baris yang mengandungi NaN (yang muncul pada permulaan kerana sejarah yang tiada) dan bahagikan data kepada set latihan dan ujian tanpa mengacak, sambil mengekalkan susunan masa.

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
# ...  ...    ...    ...

Menganjak dalam Kumpulan

Apabila data anda mengandungi berbilang entiti (contohnya, berbilang produk atau wilayah dalam satu DataFrame), anda mesti mengira anjakan dalam setiap kumpulan entiti secara berasingan. Gunakan groupby().shift() untuk memastikan bahawa nilai tertangguh bagi baris pertama produk A ialah NaN, bukannya nilai terakhir produk B. Mencampurkan kumpulan tanpa langkah ini ialah pepijat kebocoran data yang lazim dan sukar dikesan.

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)

Mentafsir Tanda pct_change

Nilai pct_change() positif bermaksud nilai semasa adalah lebih tinggi daripada nilai sebelumnya; nilai negatif bermaksud nilai semasa lebih rendah. Berhati-hati terhadap pembahagian dengan sifar apabila nilai sebelumnya ialah sifar — hasilnya ialah NaN atau inf bergantung pada tanda nilai semasa. Gunakan replace([float('inf'), float('-inf')], float('nan')) untuk membersihkan nilai tak terhingga selepas 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)

Semakan Pantas

Uji pemahaman anda tentang anjakan dan ciri tertangguh daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini anda telah mempelajari bahawa: shift(n) mencipta ciri tertangguh dengan mengalihkan nilai ke bawah sebanyak n kedudukan; diff(n) mengira perubahan mutlak antara tempoh; pct_change(n) mengira perubahan peratusan relatif; dan apabila bekerja dengan berbilang kumpulan, anda mesti menggunakan groupby().shift() untuk mengelakkan kebocoran data. Seterusnya, kita akan mengekstrak ciri temporal menggunakan pengakses .dt.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Anjakan dan Ciri Lengah” percuma?

Ya — teks penuh “Anjakan dan Ciri Lengah” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Anjakan dan Ciri Lengah”?

Cipta lajur lengah dan hadapan dengan shift(), kira perubahan antara tempoh dengan diff() dan hitung perubahan peratusan. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Anjakan dan Ciri Lengah” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pandas & NumPy Academy