Uthenting av egenskaper fra dato og klokkeslett
Deltakere vil dele datetime-kolonner opp i år, måned, ukedag og time, samt sykliske sinus-/cosinus-representasjoner som fanger opp periodisitet.
Uthenting av egenskaper fra dato og klokkeslett er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hvorfor rå tidsstempler er ubrukelige
Et rått Unix-tidsstempel som 1718784000 eller en datetime-streng som '2024-06-19 14:30:00' inneholder mye informasjon – klokkeslett, ukedag og måned – men en modell kan ikke få tilgang til denne informasjonen fra råverdien. En lineær modell ser tidsstempelet som ett stort heltall og kan bare lære at senere tidspunkter forutsier høyere eller lavere målverdier, mens alle periodiske mønstre overses. Feature-ekstraksjon deler opp tidsstempelet i meningsfulle numeriske komponenter som modeller kan bruke direkte.
Analysere datetime-kolonner med Pandas
Analyser alltid dato- og tidsstrenger til pd.Timestamp eller datatypen datetime64 ved hjelp av pd.to_datetime() før De trekker ut features. Når dataene er analysert, tilbyr Pandas en .dt-tilgang med dusinvis av attributter: .dt.year, .dt.month, .dt.day, .dt.hour, .dt.minute, .dt.dayofweek (0=mandag), .dt.dayofyear, .dt.quarter, .dt.is_weekend og flere. Hvert attributt blir en ny heltallskolonne i feature-matrisen.
import pandas as pd
dates = pd.Series(['2024-01-15 08:30:00', '2024-06-21 17:45:00', '2024-12-25 12:00:00'])
dts = pd.to_datetime(dates)
df = pd.DataFrame({
'year': dts.dt.year,
'month': dts.dt.month,
'day': dts.dt.day,
'hour': dts.dt.hour,
'dayofweek': dts.dt.dayofweek, # 0=Mon, 6=Sun
'quarter': dts.dt.quarter,
'is_weekend': (dts.dt.dayofweek >= 5).astype(int)
})
print(df.to_string())Problemet med rå sykliske features
Time 23 og 0 ligger ved siden av hverandre (én time fra hverandre), men er numerisk langt fra hverandre (23 enheter). Hvis De koder time som et heltall fra 0 til 23, kan ikke en lineær modell lære at mønstre ved midnatt ligner på mønstre klokken 23. Det samme gjelder måneder (desember og januar ligger ved siden av hverandre), ukedager (søndag=6 og mandag=0) og alle andre sykliske størrelser. Når disse behandles som rå heltall, oppstår et kunstig brudd ved syklusens grense som modellene må forsøke å håndtere.
Syklisk koding med sinus og cosinus
Løsningen er å kode sykliske features som par av sinus og cosinus. For en variabel som går fra 0 til T-1 kodes den som: sin(2π × value / T) og cos(2π × value / T). Dette avbilder syklusen på en sirkel i et todimensjonalt rom. Time 23 og time 0 er nå nabopunkter på sirkelen, så den euklidiske avstanden mellom dem er liten. Alle modeller som beregner avstander eller lineære kombinasjoner, kan nå fange opp sykliske mønstre korrekt ved å bruke sinus- og cosinuskomponentene sammen.
import numpy as np
import pandas as pd
hours = np.arange(24)
df = pd.DataFrame({'hour': hours})
df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24)
df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24)
# Distance between hour 23 and hour 0 on the circle
def circle_dist(h1, h2):
s1, c1 = df.loc[df['hour'] == h1, ['hour_sin', 'hour_cos']].values[0]
s2, c2 = df.loc[df['hour'] == h2, ['hour_sin', 'hour_cos']].values[0]
return np.sqrt((s1-s2)**2 + (c1-c2)**2)
print('Distance 23 to 0:', round(circle_dist(23, 0), 4)) # small
print('Distance 0 to 12:', round(circle_dist(0, 12), 4)) # largeBruke syklisk koding på flere features
Mønsteret for syklisk koding kan generaliseres til alle periodiske features: måned (T=12), ukedag (T=7), time (T=24), minutt (T=60) og dag i året (T=365). Hver sykliske feature genererer to nye features (sinus og cosinus). For trebaserte modeller fungerer rå heltallskoding ofte fint fordi trær deler ved terskler og kan fange opp sykliske mønstre gjennom flere delinger. For lineære modeller, nevrale nettverk og avstandsbaserte algoritmer er syklisk koding imidlertid viktig.
import numpy as np
import pandas as pd
def cyclical_encode(df, col, period):
df[col + '_sin'] = np.sin(2 * np.pi * df[col] / period)
df[col + '_cos'] = np.cos(2 * np.pi * df[col] / period)
return df
df = pd.DataFrame({'hour': [8, 12, 20, 23], 'month': [1, 6, 11, 12], 'dow': [0, 2, 4, 6]})
df = cyclical_encode(df, 'hour', 24)
df = cyclical_encode(df, 'month', 12)
df = cyclical_encode(df, 'dow', 7)
print(df[['hour', 'hour_sin', 'hour_cos', 'month', 'month_sin', 'month_cos']].round(3))Tid siden referansepunkt: relative tidsstempler
I stedet for å trekke ut kalenderkomponenter er det noen ganger forløpt tid siden en hendelse som er viktig: dager siden siste kjøp, timer siden systemet ble startet på nytt eller måneder siden kontoen ble opprettet. Disse relative varighetsfeature-ene fanger opp effekter av aktualitet som absolutte kalenderfeatures ikke får med seg. Beregn dem som enkle differanser: (now - event_date).dt.days eller (now - event_date).dt.total_seconds(). Features for aktualitet er spesielt verdifulle i modeller for kundeatferd (churn og LTV) og prediktivt vedlikehold.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'last_purchase': pd.to_datetime(['2024-01-10', '2024-05-20', '2024-06-15']),
'signup_date': pd.to_datetime(['2023-01-01', '2023-06-15', '2024-01-01'])
})
reference = pd.Timestamp('2024-06-19')
df['days_since_purchase'] = (reference - df['last_purchase']).dt.days
df['account_age_days'] = (reference - df['signup_date']).dt.days
print(df[['days_since_purchase', 'account_age_days']])Flagg for helg og arbeidstid
Boolsk indikatorfeatures som er utledet fra tidsstempler, er enkle, men ofte effektive. is_weekend, is_business_hours, is_holiday, is_month_end – disse oppretter tydelige binære delinger som trebaserte modeller kan utnytte i én enkelt deling. Lineære modeller har også nytte av dem fordi disse flaggene oppretter separate justeringer av konstantleddet. Et flagg for offentlige helligdager kan være spesielt nyttig i modeller for detaljhandelssalg, trafikk og energiforbruk, der helligdager fører til systematiske endringer i etterspørselen.
import pandas as pd
dates = pd.to_datetime(['2024-06-17', '2024-06-19', '2024-06-21', '2024-06-22', '2024-12-25'])
df = pd.DataFrame({'date': dates})
df['is_weekend'] = (df['date'].dt.dayofweek >= 5).astype(int)
df['is_month_end'] = df['date'].dt.is_month_end.astype(int)
df['is_quarter_end'] = df['date'].dt.is_quarter_end.astype(int)
df['week_of_year'] = df['date'].dt.isocalendar().week.astype(int)
print(df.to_string())Lag-features og rullerende statistikk
For tidsseriedata er tidligere verdier av målvariabelen ofte blant de beste prediktorene. Lag-features forskyver målet med N tidssteg: df['target_lag1'] = df['target'].shift(1) oppretter en feature som er lik gårsdagens målverdi. Rullerende statistikk oppsummerer den siste historikken: df['rolling_mean_7'] = df['target'].rolling(7).mean() gir et glidende gjennomsnitt over sju dager. Disse feature-ene koder inn tidsmessig momentum og sesongvariasjon som kalenderfeatures alene ikke kan fange opp.
import pandas as pd
import numpy as np
np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=10)
sales = np.array([100, 120, 95, 130, 110, 145, 160, 155, 170, 180])
df = pd.DataFrame({'date': dates, 'sales': sales})
df['lag_1'] = df['sales'].shift(1)
df['lag_7'] = df['sales'].shift(7)
df['rolling_mean_3'] = df['sales'].rolling(3).mean()
df['rolling_std_3'] = df['sales'].rolling(3).std()
print(df.to_string())Kombinere datofeatures i en pipeline
For å bruke datoekstraksjon i en scikit-learn Pipeline uten lekkasje oppretter De en egendefinert transformer ved hjelp av BaseEstimator og TransformerMixin. Dette sikrer at datofeatures beregnes konsekvent og reproduserbart i hver fold av kryssvalideringen. Vær ekstra forsiktig med lag- og rullerende features – rullerende statistikk som beregnes på hele datasettet (inkludert fremtidige testdata), vil lekke informasjon. Beregn alltid lag- og rullerende features bare frem til treningsskjæringsdatoen.
import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin
class DateFeatureExtractor(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
return self
def transform(self, X):
X = X.copy()
dt = pd.to_datetime(X['date'])
X['hour'] = dt.dt.hour
X['dayofweek'] = dt.dt.dayofweek
X['month'] = dt.dt.month
X['hour_sin'] = np.sin(2 * np.pi * X['hour'] / 24)
X['hour_cos'] = np.cos(2 * np.pi * X['hour'] / 24)
X = X.drop('date', axis=1)
return X
df = pd.DataFrame({'date': ['2024-06-19 08:00', '2024-06-20 15:30'], 'value': [10, 20]})
print(DateFeatureExtractor().fit_transform(df))Velge features basert på domenekunnskap
Effektiv feature engineering for datetime-data krever forståelse av hvilke tidsmønstre som er viktige for problemet Deres. For etterspørsel etter samkjøringstjenester er klokkeslett og ukedag avgjørende. For detaljhandelssalg er ukedag, uke i året, avstand til helligdager og utviklingen fra år til år viktige. For deteksjon av nettverksinntrengning er tid siden siste hendelse og utbruddsrate relevante. For energiforbruk er samspill mellom time, dag og temperatur viktig. Start alltid med å plotte målet mot hver tidskomponent for å identifisere synlige periodiske mønstre før De konstruerer features.
Håndtere flere tidssoner
Når datasettet dekker flere tidssoner, må De alltid konvertere tidsstemplene til én felles referansesone før feature-ekstraksjon. Det er vanlig praksis å bruke UTC som kanonisk tidssone. Etter at De har trukket ut features, kan De bruke lokale tidsforskyvninger på nytt dersom lokale mønstre er viktige (for eksempel er klokkeslettet i kundens lokale tid mer prediktivt enn UTC-klokkeslettet for modellering av bruker atferd). Pandas-metodene dt.tz_localize() og dt.tz_convert() håndterer konvertering av tidssoner på en ryddig måte.
import pandas as pd
# Timestamps in mixed timezones
timestamps = ['2024-06-19 08:00:00-05:00', # US/Chicago
'2024-06-19 14:00:00+01:00', # Europe/London
'2024-06-19 22:00:00+09:00'] # Asia/Tokyo
df = pd.DataFrame({'ts': pd.to_datetime(timestamps, utc=True)})
df['utc_hour'] = df['ts'].dt.hour # all in UTC after conversion
df['ts_ny'] = df['ts'].dt.tz_convert('America/New_York')
df['ny_hour'] = df['ts_ny'].dt.hour # local time hour
print(df[['utc_hour', 'ny_hour']])Hurtigsjekk
Test forståelsen Deres av feature-ekstraksjon fra dato og tid i denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at: rå tidsstempler må deles opp i meningsfulle komponenter før de brukes som features, sykliske features som time og måned krever sinus-/cosinuskoding for å unngå brudd ved grensen, og lag- og rullerende features koder inn tidsmønstre for prediksjonsoppgaver med tidsserier. Neste tema er feature-seleksjon med Variance Threshold og SelectKBest for å forkaste features uten informasjonsverdi.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Uthenting av egenskaper fra dato og klokkeslett» gratis?
Ja – hele teksten i «Uthenting av egenskaper fra dato og klokkeslett» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Uthenting av egenskaper fra dato og klokkeslett»?
Deltakere vil dele datetime-kolonner opp i år, måned, ukedag og time, samt sykliske sinus-/cosinus-representasjoner som fanger opp periodisitet. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Machine Learning Academy?
Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Uthenting av egenskaper fra dato og klokkeslett»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?
Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Opprette nye egenskaper: Log-transformasjoner, kategorisering og interaksjoner
- Uthenting av egenskaper fra dato og klokkeslett
- Egenskapsutvelgelse: Variansgrense og SelectKBest
- Rekursiv egenskapseliminering med kryssvalidering