Natuurlijk! Hier is een overzicht van hoe je een ARIMA-model kunt implementeren voor jouw temperatuurgegevens, inclusief een voorbeeld van een NumPy-achtige aanpak en belangrijke overwegingen. **Datasetkenmerken:** - Tijdreeks: Temperatuurmetingen - Periode: Januari 2015 tot december 2020 - Frequentie: Maandelijks (bijvoorbeeld, 12 metingen per jaar) - Mogelijke kenmerken: seizoensinvloeden, trend, niet-stationariteit --- ### Stap 1: Data Voorbereiding Omdat ARIMA-implementaties vaak gebruik maken van gespecialiseerde bibliotheken zoals `statsmodels`, is het belangrijk te weten dat NumPy zelf niet direct ARIMA-functies bevat. Maar je kunt wel de data voorbereiden en de kern van de berekeningen uitvoeren. ### Stap 2: Stationariteit controleren en transformeren ARIMA vereist meestal stationaire data. Je kunt de data transformeren door: - Differentiatie (om trend weg te nemen) - Seizoensaanpassingen (bijv. seizoensdifferentiatie) ### Stap 3: Hyperparameters - **p (autoregressief):** aantal lag-waarden - **d (integratie):** aantal differentiatie-verschillen - **q (moving average):** aantal lag-voorspellingen in de error-term Voor het bepalen van de optimale hyperparameters kun je: - Kijk naar de ACF- en PACF-plots - Gebruik criteria als AIC of BIC voor modelselectie ### Stap 4: Implementatie voorbeeld (met `statsmodels`) Hier is een voorbeeld in Python met `statsmodels` (een veelgebruikte bibliotheek voor ARIMA): ```python import numpy as np import pandas as pd import statsmodels.api as sm # Stel dat je data in een Pandas Series hebt: # Bijvoorbeeld: temp_series = pd.Series(jouw_temperatuurdata, index=datum_index) # Data voorbereiden (voorbeeld) # temp_series = pd.Series(data, index=pd.date_range(start='2015-01-01', end='2020-12-01', freq='MS')) # Model fitten model = sm.tsa.statespace.SARIMAX(temp_series, order=(p, d, q)) result = model.fit() # Voorspelling maken forecast = result.get_forecast(steps=12) # bijvoorbeeld 12 maanden vooruit pred_ci = forecast.conf_int() # Resultaten bekijken print(result.summary()) ``` ### Overwegingen voor hyperparameter afstemming: - Gebruik **grid search** over p, d, q gecombineerd met AIC/BIC om het beste model te selecteren. - Controleer de residuals op autocorrelatie (met plots of Ljung-Box test). ### Model evaluatiemetrics: - **AIC (Akaike Information Criterion):** lager is beter, geeft modelparsimony en fit - **BIC (Bayesian Information Criterion):** vergelijkbaar met AIC, met zwaardere straf voor meer parameters - **RMSE of MAE:** voor het meten van voorspellingsfout op een testset --- ### Samenvatting: - Gebruik `statsmodels` voor ARIMA-modellering - Zorg voor stationariteit via differentiatie en seizoensaanpassing - Bepaal hyperparameters via ACF/PACF en modelselectiecriteria - Evalueer modellen met AIC, BIC, RMSE --- **Let op:** NumPy zelf bevat geen ARIMA-implementatie, daarom wordt `statsmodels` aanbevolen. Wil je een volledige zelfgeschreven ARIMA in pure NumPy, dan is dat complex en meestal niet aan te raden; het is handiger om bestaande bibliotheken te gebruiken. Als je verdere hulp nodig hebt bij de code of interpretatie, laat het gerust weten!

Ik zal je helpen een ARIMA-implementatie te maken met NumPy, hoewel ik moet opmerken dat NumPy alleen niet voldoende is voor een complete ARIMA-implementatie. We zullen ook statsmodels gebruiken, wat de standaard aanpak is in Python. Eerst zal ik de basisstructuur tonen: ```python import numpy as np import pandas as pd import matplotlib.pyplot as plt from statsmodels.tsa.arima.model import ARIMA from statsmodels.tsa.stattools import adfuller from sklearn.metrics import mean_squared_error, mean_absolute_error # Voor je temperatuurdataset (jan 2015 - dec 2020) def prepare_temperature_data(): """ Voorbeeld dataset - vervang dit met je echte data Maandelijkse temperatuurmetingen van januari 2015 tot december 2020 """ dates = pd.date_range('2015-01', '2020-12', freq='M') # Voorbeeld data - normale verdeling met seizoenspatroon np.random.seed(42) base_temp = 15 seasonal = 10 * np.sin(2 * np.pi * np.arange(len(dates)) / 12) noise = np.random.normal(0, 2, len(dates)) temperatures = base_temp + seasonal + noise return pd.Series(temperatures, index=dates, name='Temperatuur') def check_stationarity(timeseries): """Controleer stationariteit met Augmented Dickey-Fuller test""" result = adfuller(timeseries) print(f'ADF Statistic: {result[0]}') print(f'p-value: {result[1]}') print(f'Critical Values: {result[4]}') return result[1] <= 0.05 def find_best_arima_params(timeseries, max_p=3, max_d=2, max_q=3): """Vind optimale ARIMA parameters met AIC/BIC""" best_aic = np.inf best_bic = np.inf best_params = None for p in range(max_p + 1): for d in range(max_d + 1): for q in range(max_q + 1): try: model = ARIMA(timeseries, order=(p, d, q)) fitted_model = model.fit() if fitted_model.aic < best_aic: best_aic = fitted_model.aic best_params_aic = (p, d, q) if fitted_model.bic < best_bic: best_bic = fitted_model.bic best_params_bic = (p, d, q) except: continue print(f"Beste parameters (AIC): {best_params_aic}, AIC: {best_aic:.2f}") print(f"Beste parameters (BIC): {best_params_bic}, BIC: {best_bic:.2f}") return best_params_aic, best_params_bic def evaluate_arima_model(timeseries, order, train_ratio=0.8): """Train en evalueer ARIMA model""" # Split data split_idx = int(len(timeseries) * train_ratio) train, test = timeseries[:split_idx], timeseries[split_idx:] # Train model model = ARIMA(train, order=order) fitted_model = model.fit() # Voorspellingen forecast = fitted_model.forecast(steps=len(test)) # Evaluatiemetrics mse = mean_squared_error(test, forecast) mae = mean_absolute_error(test, forecast) rmse = np.sqrt(mse) print(f"\nModel Evaluatie:") print(f"MSE: {mse:.2f}") print(f"MAE: {mae:.2f}") print(f"RMSE: {rmse:.2f}") print(f"AIC: {fitted_model.aic:.2f}") print(f"BIC: {fitted_model.bic:.2f}") return fitted_model, forecast, (mse, mae, rmse) # Hoofdimplementatie def main(): # Laad en bereid data voor temperature_data = prepare_temperature_data() print("Dataset Kenmerken:") print(f"Periode: {temperature_data.index[0]} tot {temperature_data.index[-1]}") print(f"Aantal observaties: {len(temperature_data)}") print(f"Gemiddelde temperatuur: {temperature_data.mean():.2f}°C") print(f"Standaardafwijking: {temperature_data.std():.2f}°C") # Controleer stationariteit print("\nStationariteit Test:") is_stationary = check_stationarity(temperature_data) print(f"Dataset is stationair: {is_stationary}") # Zoek beste parameters print("\nHyperparameter Optimalisatie:") best_aic_params, best_bic_params = find_best_arima_params(temperature_data) # Gebruik AIC-parameters (meest gebruikelijk) print(f"\nTraining model met parameters: {best_aic_params}") model, forecast, metrics = evaluate_arima_model(temperature_data, best_aic_params) # Toon model samenvatting print("\nModel Samenvatting:") print(model.summary()) # Visualisatie plt.figure(figsize=(12, 6)) plt.plot(temperature_data.index, temperature_data.values, label='Werkelijke Data') # Voorspelling plotten split_idx = int(len(temperature_data) * 0.8) forecast_index = temperature_data.index[split_idx:] plt.plot(forecast_index, forecast, label='Voorspelling', color='red') plt.title('Temperatuur Voorspelling met ARIMA') plt.xlabel('Datum') plt.ylabel('Temperatuur (°C)') plt.legend() plt.grid(True) plt.show() if __name__ == "__main__": main() ``` **Belangrijke overwegingen voor je temperatuurdataset:** 1. **Seizoenspatroon**: Temperatuurdata heeft sterke seizoensinvloeden. Overweeg SARIMA voor seizoenscomponenten. 2. **Stationariteit**: Temperatuurdata is vaak niet stationair. Gebruik differencing (d parameter) om stationariteit te bereiken. 3. **Hyperparameter afstemming**: - **p (AR)**: Aantal lag-observaties (meestal 0-3) - **d (I)**: Differencing orde (meestal 0-2) - **q (MA)**: Grootte moving average window (meestal 0-3) 4. **Model evaluatie**: - **AIC**: Beter voor model vergelijking - **BIC**: Sterkere penalty voor complexiteit - **RMSE/MAE**: Voor voorspellingsnauwkeurigheid 5. **Voor je specifieke dataset**: ```python # Voor seizoensgebonden temperatuurdata overweeg: from statsmodels.tsa.statespace.sarimax import SARIMAX # SARIMA model met seizoenscomponenten seasonal_model = SARIMAX(temperature_data, order=(1,1,1), seasonal_order=(1,1,1,12)) ``` Wil je dat ik specifieke aspecten aanpas voor je temperatuurdata of aanvullende functionaliteit toevoeg?