Absoluut. Laten we de specifieke eisen voor uw tijdreeksanalyse doornemen en hier efficiënte, op NumPy gebaseerde oplossingen voor ontwikkelen. ### Aard van de Data & Uitdagingen Uw dataset (`dagelijkse_slotkoersen`) heeft de volgende kenmerken: * **Dimensie:** 1D-array (of 2D voor meerdere aandelen) met ~3650 datapunten (10 jaar * 365 dagen). * **Frequentie:** Dagelijks (werkdagen), wat weekends en feestdagen uitsluit. * **Uitdagingen:** Ontbrekende waarden (op dagen zonder handel, zoals weekends), mogelijk uitschieters, en complexe seizoenspatronen (wekelijkse, maandelijkse, jaarlijkse cycli). ### Kernanalysetaken 1. **Trenddetectie:** Het identificeren van de onderliggende, langetermijnrichting (stijgend, dalend, zijwaarts) van de aandelenkoers. 2. **Seizoensdetectie:** Het blootleggen van zich herhalende patronen binnen een vaste periode (bijv. wekelijkse effecten, "sell in May", einde-jaarsrally). --- ### Ontwikkelde Aangepaste Functies Hieronder vindt u efficiënte NumPy-implementaties die rekening houden met de tijdsdimensie en ontbrekende waarden. #### 1. Functie voor het verwijderen van ontbrekende waarden (`nan_cleaner`) Deze functie verwijdert `NaN`-waarden en hun corresponderende datums, wat cruciaal is voor veel numerieke algoritmes. ```python import numpy as np def nan_cleaner(time_series, dates): """ Verwijdert ontbrekende waarden (NaN) uit een tijdreeks en de bijbehorende datums. Parameters: time_series (np.ndarray): De invoertijdreeks (mogelijk met NaN's). dates (np.ndarray): Array van datums of tijdsindices, even lang als time_series. Returns: tuple: (cleaned_series, cleaned_dates) zonder de entries waar time_series NaN was. """ # Creëer een masker dat True is op alle posities die géén NaN zijn valid_mask = ~np.isnan(time_series) # Filter zowel de tijdreeks als de datums met dit masker cleaned_series = time_series[valid_mask] cleaned_dates = dates[valid_mask] return cleaned_series, cleaned_dates # Gebruiksvoorbeeld: # cleaned_prices, cleaned_dates = nan_cleaner(dagelijkse_slotkoersen, datum_array) ``` #### 2. Functie voor trenddetectie met Moving Average (`trend_detector`) Een simpele maar effectieve trendindicator. De grootte van het venster bepaalt hoe "glad" de trendlijn is. ```python def trend_detector(time_series, window_size=30): """ Bereken een simpele trendlijn met behulp van een Simple Moving Average (SMA). Parameters: time_series (np.ndarray): De invoertijdreeks (zonder NaN's voor een zuiver resultaat). window_size (int): De grootte van het moving average venster (bijv. 30 voor ~1 maand). Returns: np.ndarray: De trendlijn, met dezelfde lengte als de input. De eerste `window_size - 1` punten zijn NaN. """ # Gebruik NumPy's convolutie voor een efficiënte SMA berekening trend = np.convolve(time_series, np.ones(window_size)/window_size, mode='valid') # Pad het resultaat aan het begin met NaN's om de lengte gelijk te houden padded_trend = np.full_like(time_series, np.nan, dtype=np.float64) padded_trend[window_size-1:] = trend return padded_trend # Gebruiksvoorbeeld (na het opschonen van NaN's): # trendlijn = trend_detector(cleaned_prices, window_size=50) # ~50 werkdagen = ~2.5 maand ``` #### 3. Functie voor seizoensdetectie met Periodiek Gemiddelde (`seasonality_detector`) Deze functie isoleert het seizoenspatroon door voor elke periode in een cyclus (bijv. elke dag van de week) het gemiddelde te berekenen. ```python def seasonality_detector(time_series, dates, period='week'): """ Detecteert een seizoenspatroon door het gemiddelde per periode te berekenen (bv. per dag van de week). Parameters: time_series (np.ndarray): De invoertijdreeks (zonder NaN's). dates (np.ndarray): Array van datetime64 objecten, even lang als time_series. Returns: dict: Een dictionary met de periode-index (bv. 0 voor Maandag) als key en het gemiddelde als value. """ # Bepaal de periode-index voor elk datapunt if period.lower() == 'week': # .dayofweek: Maandag=0, Zondag=6 period_indices = np.array([d.astype('datetime64[D]').astype(int) % 7 for d in dates]) elif period.lower() == 'year': # .dayofyear: 1 tot 365/366 period_indices = np.array([d.astype('datetime64[D]').astype('datetime64[Y]').astype(int) for d in dates]) else: raise ValueError("Ondersteunde periodes: 'week', 'year'") # Initialiseer een dictionary om de som en telling per index bij te houden season_dict = {} # Vul de dictionary for idx, period_index in enumerate(period_indices): if period_index not in season_dict: season_dict[period_index] = {'sum': 0, 'count': 0} season_dict[period_index]['sum'] += time_series[idx] season_dict[period_index]['count'] += 1 # Bereken het gemiddelde voor elke periode-index seasonal_pattern = {k: v['sum'] / v['count'] for k, v in season_dict.items()} return seasonal_pattern # Gebruiksvoorbeeld: # weekly_seasonality = seasonality_detector(cleaned_prices, cleaned_dates, period='week') # print("Gemiddelde koers per weekdag:", weekly_seasonality) ``` ### Geïntegreerd Werkflow Voorbeeld ```python # 1. Data voorbereiden (veronderstel dat `prices` en `dates` arrays zijn geladen) cleaned_prices, cleaned_dates = nan_cleaner(prices, dates) # 2. Trend analyseren lange_termijn_trend = trend_detector(cleaned_prices, window_size=252) # Venster van ~1 jaar (252 werkdagen) # 3. Seizoen analyseren wekelijkse_seizoen = seasonality_detector(cleaned_prices, cleaned_dates, period='week') # 4. Seizoensgeadjusteerde reeks berekenen (indien gewenst) # Dit verwijdert het seizoenseffect om de onderliggende trend en ruwheid beter te zien. seasonal_component = np.array([wekelijkse_seizoen[d.astype('datetime64[D]').astype(int) % 7] for d in cleaned_dates]) seasonally_adjusted_series = cleaned_prices - seasonal_component # De seasonally_adjusted_series is nu klaar voor verdere modellering, zoals voorspellingen. ``` ### Volgende Stap: Voorspellingsmodellen Met deze voorbewerkte data kunt u nu robustere voorspellingsmodellen bouwen. Overweeg: 1. **ARIMA (AutoRegressive Integrated Moving Average):** Klassieke methode voor stationaire reeksen. Gebruik de `seasonally_adjusted_series` als input. 2. **LSTM (Long Short-Term Memory) Netwerken:** Een type RNN dat uitstekend is in het leren van lange-termijn afhankelijkheden in tijdreeksen. Hiervoor zou u bibliotheken zoals TensorFlow/Keras gebruiken, met NumPy arrays als input. Deze aangepaste functies vormen een solide foundation voor uw analyse. Ze zijn efficiënt voor datasets van deze omvang en hanteren de belangrijkste uitdagingen direct.