Natuurlijk! Hieronder geef ik een stapsgewijze uitleg en codevoorbeelden om een tijdreeksvoorspellingsmodel te bouwen met Scikit-learn, gebaseerd op de door jou genoemde algoritmen en preprocessing-stappen. **Stap 1: Data voorbereiden** Omdat je tijdreeksgegevens hebt, moeten we rekening houden met de sequentiële aard. Een veelgebruikte aanpak is om lag-variabelen (voorgaande dagen) te maken zodat het model patronen in de tijd kan leren. **Stap 2: Feature engineering** Maak bijvoorbeeld gebruik van voorgaande dagen (lags) als features. Bijvoorbeeld: temperatuur van dag t-1, t-2, etc. **Stap 3: Normalisatie en missing values imputatie** Gebruik bijvoorbeeld StandardScaler voor normalisatie en SimpleImputer voor ontbrekende waarden. **Stap 4: Train-test splitsing op basis van tijd** Splits de data chronologisch, niet willekeurig. **Stap 5: Model trainen en evalueren** Gebruik RandomForestRegressor en GradientBoostingRegressor. Hieronder de code: ```python import pandas as pd import numpy as np from sklearn.model_selection import train_test_split from sklearn.impute import SimpleImputer from sklearn.preprocessing import StandardScaler from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor from sklearn.metrics import mean_squared_error # Voorbeeld: Laad je data (vervang door je eigen data inlezen) # data = pd.read_csv('jouw_data.csv', parse_dates=['datum']) # Stel je hebt een DataFrame 'data' met kolommen: 'datum', 'slotkoers', 'temperatuur' # Sorteren op datum data = data.sort_values('datum').reset_index(drop=True) # Maak lag features voor de temperatuur (bijvoorbeeld 1 t/m 3 dagen terug) lags = [1, 2, 3] for lag in lags: data[f'temp_lag_{lag}'] = data['temperatuur'].shift(lag) # Verwijder rijen met NaN waarden die ontstaan door lag functies data = data.dropna().reset_index(drop=True) # Definieer features en target X = data[[f'temp_lag_{lag}' for lag in lags]] y = data['temperatuur'] # Of een andere variabele die je wilt voorspellen # Normaliseer features scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # Impute ontbrekende waarden (indien nog aanwezig) imputer = SimpleImputer(strategy='mean') X_imputed = imputer.fit_transform(X_scaled) # Split data chronologisch in training en test # Bijvoorbeeld: 80% voor training, 20% voor test split_index = int(len(X) * 0.8) X_train, X_test = X_imputed[:split_index], X_imputed[split_index:] y_train, y_test = y[:split_index], y[split_index:] # Train modellen rf_model = RandomForestRegressor(n_estimators=100, random_state=42) gb_model = GradientBoostingRegressor(n_estimators=100, random_state=42) rf_model.fit(X_train, y_train) gb_model.fit(X_train, y_train) # Voorspellingen y_pred_rf = rf_model.predict(X_test) y_pred_gb = gb_model.predict(X_test) # Evaluatie rmse_rf = np.sqrt(mean_squared_error(y_test, y_pred_rf)) rmse_gb = np.sqrt(mean_squared_error(y_test, y_pred_gb)) print(f'Random Forest RMSE: {rmse_rf}') print(f'Gradient Boosting RMSE: {rmse_gb}') ``` **Uitleg:** - We maken lag-variabelen om de tijdselementen vast te leggen. - We verwijderen rijen met NaN-waarden die ontstaan door de lag-werking. - Normaliseren en imputeren zorgen dat de data geschikt is voor de modellen. - Chronologische splitsing voorkomt dat informatie uit de toekomst in de training terechtkomt. - Na training worden voorspellingen gedaan en geëvalueerd met RMSE. **Aanpassingen:** - Pas de lag-periodes aan afhankelijk van de patronen in jouw data. - Voeg meer features toe (bijvoorbeeld dag van de week, maand, etc.) voor betere prestaties. - Experimenteer met hyperparameters. Wil je verdere hulp bij optimalisatie of visualisatie?

Hallo! Ik zie een fundamentele uitdaging in je verzoek: je wilt een model bouwen dat dagelijkse slotkoersen van aandelen gebruikt om **temperatuur** te voorspellen. Dit zijn twee totaal verschillende soorten gegevens zonder duidelijke causale relatie. Laten we eerst dit bespreken voordat we naar code kijken. ## Eerst: Begrijp je probleem Aandelenkoersen en temperatuur hebben geen directe voorspellende relatie. Mogelijk bedoel je: 1. **Temperatuur voorspellen** → dan heb je historische temperatuurdata nodig 2. **Aandelenkoersen voorspellen** → dan is je doelvariabele de koers zelf Ik ga ervan uit dat je **aandelenkoersen wilt voorspellen** en toevallig "temperatuur" hebt getypt. ## Tijdreeksvoorbereiding code ```python import pandas as pd import numpy as np from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor from sklearn.model_selection import TimeSeriesSplit, cross_val_score from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.preprocessing import StandardScaler from sklearn.impute import SimpleImputer # Laad je data (voorbeeld) # df = pd.read_csv('aandelen_data.csv', parse_dates=['Datum'], index_col='Datum') # Voorbeeld dataframe als placeholder dates = pd.date_range(start='2018-01-01', end='2023-12-31', freq='D') df = pd.DataFrame({ 'Datum': dates, 'Slotkoers': np.random.randn(len(dates)).cumsum() + 100, # Random walk 'Volume': np.random.randint(1000, 10000, len(dates)) }) df.set_index('Datum', inplace=True) # Maak tijdgebonden features def create_time_features(df): df = df.copy() df['dag_van_week'] = df.index.dayofweek df['dag_van_maand'] = df.index.day df['maand'] = df.index.month df['kwartaal'] = df.index.quarter df['jaar'] = df.index.year df['dag_van_jaar'] = df.index.dayofyear return df df = create_time_features(df) # Creëer vertraagde features (lags) def create_lag_features(df, target_col, lags=[1, 2, 3, 5, 7, 14, 30]): for lag in lags: df[f'{target_col}_lag_{lag}'] = df[target_col].shift(lag) return df df = create_lag_features(df, 'Slotkoers') # Rolllende statistieken def create_rolling_features(df, target_col, windows=[7, 14, 30]): for window in windows: df[f'{target_col}_roll_mean_{window}'] = df[target_col].rolling(window=window).mean() df[f'{target_col}_roll_std_{window}'] = df[target_col].rolling(window=window).std() return df df = create_rolling_features(df, 'Slotkoers') # Verwijder rijen met NaN waarden (door shifting) df.dropna(inplace=True) # Scheid features en target X = df.drop('Slotkoers', axis=1) y = df['Slotkoers'] # Train-test split (tijdreeks-safe!) test_size = int(len(X) * 0.2) # 20% voor testing X_train, X_test = X[:-test_size], X[-test_size:] y_train, y_test = y[:-test_size], y[-test_size:] # Preprocessing imputer = SimpleImputer(strategy='mean') scaler = StandardScaler() X_train_imputed = imputer.fit_transform(X_train) X_test_imputed = imputer.transform(X_test) X_train_scaled = scaler.fit_transform(X_train_imputed) X_test_scaled = scaler.transform(X_test_imputed) ``` ## Model training en evaluatie ```python # Initialiseer modellen rf_model = RandomForestRegressor( n_estimators=100, random_state=42, n_jobs=-1 ) gb_model = GradientBoostingRegressor( n_estimators=100, random_state=42, learning_rate=0.1 ) # Train modellen rf_model.fit(X_train_scaled, y_train) gb_model.fit(X_train_scaled, y_train) # Voorspellingen rf_preds = rf_model.predict(X_test_scaled) gb_preds = gb_model.predict(X_test_scaled) # Evaluatie def evaluate_model(y_true, y_pred, model_name): mae = mean_absolute_error(y_true, y_pred) mse = mean_squared_error(y_true, y_pred) rmse = np.sqrt(mse) print(f"{model_name} Resultaten:") print(f"MAE: {mae:.4f}") print(f"RMSE: {rmse:.4f}") print(f"MSE: {mse:.4f}") print("-" * 30) evaluate_model(y_test, rf_preds, "Random Forest") evaluate_model(y_test, gb_preds, "Gradient Boosting") # Feature importance feature_importance = pd.DataFrame({ 'feature': X.columns, 'importance': rf_model.feature_importances_ }).sort_values('importance', ascending=False) print("Belangrijkste features:") print(feature_importance.head(10)) ``` ## Tijdreeks cross-validatie ```python # Gebruik TimeSeriesSplit voor betere evaluatie tscv = TimeSeriesSplit(n_splits=5) rf_scores = cross_val_score( rf_model, X_train_scaled, y_train, cv=tscv, scoring='neg_mean_squared_error' ) print(f"Random Forest Cross-Validation RMSE: {np.sqrt(-rf_scores.mean()):.4f}") ``` ## Belangrijke aanbevelingen: 1. **Probleemdefinitie**: Zorg dat je doelvariabele logisch is 2. **Stationariteit**: Controleer of je tijdreeks stationair is 3. **Features**: Experimenteer met verschillende lag-waarden 4. **Hyperparameter tuning**: Gebruik GridSearchCV voor optimale parameters 5. **Alternatieve modellen**: Overweeg ARIMA of LSTM-netwerken voor tijdreeksen Wil je dat ik me aanpas aan een specifiekere use-case of heb je aanvullende vragen over de implementatie?