Hier is een voorbeeld van een NumPy-gebaseerde implementatie voor polynomiale regressie van graad 2 op de maandelijkse verkoopgegevens over drie jaar (36 data punten). Ik neem ook overwegingen voor overfitting en model evaluatie mee. ```python import numpy as np import matplotlib.pyplot as plt # Voorbeeld dataset: maandelijkse verkoopcijfers (bijvoorbeeld) # Vervang deze door je eigen data maanden = np.arange(1, 37) # Maanden 1 tot 36 verkoopcijfers = np.array([/* jouw data hier invullen */]) # 36 waarden # 1. Reshape de data X = maanden.reshape(-1, 1) y = verkoopcijfers # 2. Polynomial features van graad 2 degree = 2 # Vandermonde matrix voor polynomial features X_poly = np.vander(X.squeeze(), degree + 1, increasing=True) # 3. Oplossen via least squares coeffs = np.linalg.inv(X_poly.T @ X_poly) @ X_poly.T @ y # 4. Voorspellingen maken X_fit = np.linspace(1, 36, 100).reshape(-1,1) X_fit_poly = np.vander(X_fit.squeeze(), degree + 1, increasing=True) y_pred = X_fit_poly @ coeffs # 5. Model evaluatie # Voorspellingen op de trainingsdata y_train_pred = X_poly @ coeffs # Mean Squared Error (MSE) op training data mse = np.mean((y - y_train_pred) ** 2) # R^2 score ss_total = np.sum((y - np.mean(y)) ** 2) ss_residual = np.sum((y - y_train_pred) ** 2) r2 = 1 - (ss_residual / ss_total) print(f"Coefficients: {coeffs}") print(f"Mean Squared Error: {mse}") print(f"R^2: {r2}") # 6. Overwegingen overfitting # - Een graad 2 polynomial is meestal geschikt voor een matige curve. # - Als je merkt dat de fit te complex wordt en het model te nauw aansluit op de trainingsdata (bijvoorbeeld zeer hoge R^2, maar slechte generalisatie), overweeg dan om de graad te verlagen. # - Gebruik eventueel kruisvalidering (niet in deze basiscode) om overfitting te voorkomen. # 7. Plotten plt.scatter(maanden, verkoopcijfers, label='Data') plt.plot(X_fit, y_pred, color='red', label='Polynomial fit') plt.xlabel('Maand') plt.ylabel('Verkoopcijfers') plt.title('Polynomiale regressie graad 2') plt.legend() plt.show() ``` **Overwegingen:** - Kies de polynomial graad zorgvuldig; te hoog kan overfitting veroorzaken. - Gebruik validatiesets of kruisvalidering om modelprestaties te beoordelen. - Kijk naar metrics zoals MSE en R^2, maar wees voorzichtig met te hoge R^2-waarden die kunnen wijzen op overfitting. Pas de dataset aan en experimenteer met de graad van het polynomial om de beste balans te vinden tussen fit en generalisatie.

Hier is een uitgebreide NumPy-implementatie voor polynomiale regressie met graad 2 voor maandelijkse verkoopcijfers: ```python import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import r2_score, mean_squared_error from sklearn.model_selection import train_test_split def polynomiale_regressie(X, y, graad=2, test_size=0.2, random_state=42): """ Voert polynomiale regressie uit met overfitting-preventie en evaluatie Parameters: X: array-achtig - Onafhankelijke variabele (maanden) y: array-achtig - Afhankelijke variabele (verkoopcijfers) graad: int - Graad van het polynoom (default: 2) test_size: float - Grootte van testset voor validatie random_state: int - Seed voor reproduceerbaarheid Returns: dict - Model resultaten en evaluatiemetrics """ # Conversie naar NumPy arrays X = np.array(X).reshape(-1, 1) y = np.array(y) # Train-test split voor overfitting-preventie X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=test_size, random_state=random_state ) # Polynomiale features creëren def create_polynomial_features(X, degree): """Creëert polynomiale features tot opgegeven graad""" X_poly = np.ones((len(X), degree + 1)) for i in range(1, degree + 1): X_poly[:, i] = X.flatten() ** i return X_poly X_poly_train = create_polynomial_features(X_train, graad) X_poly_test = create_polynomial_features(X_test, graad) # Normalisatie voor numerieke stabiliteit def normalize_features(X): """Normaliseert features voor betere convergentie""" mean = np.mean(X, axis=0) std = np.std(X, axis=0) std[std == 0] = 1 # Voorkom delen door nul return (X - mean) / std, mean, std X_poly_train_norm, mean_train, std_train = normalize_features(X_poly_train) X_poly_test_norm = (X_poly_test - mean_train) / std_train # Gewone kleinste kwadraten oplossing met regularisatie (Ridge) def ridge_regression(X, y, alpha=0.01): """Voert ridge regression uit om overfitting tegen te gaan""" n_features = X.shape[1] I = np.eye(n_features) I[0, 0] = 0 # Regulariseer bias term niet theta = np.linalg.inv(X.T @ X + alpha * I) @ X.T @ y return theta # Model training met regularisatie alpha = 0.1 # Regularisatie parameter theta = ridge_regression(X_poly_train_norm, y_train, alpha) # Voorspellingen def predict(X_poly, theta, mean, std): """Maakt voorspellingen met genormaliseerde features""" X_norm = (X_poly - mean) / std return X_norm @ theta y_pred_train = predict(X_poly_train, theta, mean_train, std_train) y_pred_test = predict(X_poly_test, theta, mean_train, std_train) # Model evaluatie metrics def calculate_metrics(y_true, y_pred): """Berekent verschillende evaluatiemetrics""" mse = mean_squared_error(y_true, y_pred) rmse = np.sqrt(mse) r2 = r2_score(y_true, y_pred) mae = np.mean(np.abs(y_true - y_pred)) return { 'MSE': mse, 'RMSE': rmse, 'R²': r2, 'MAE': mae } train_metrics = calculate_metrics(y_train, y_pred_train) test_metrics = calculate_metrics(y_test, y_pred_test) # Overfitting detectie overfitting_indicator = train_metrics['R²'] - test_metrics['R²'] # Volledige dataset voorspelling voor visualisatie X_full_poly = create_polynomial_features(X, graad) y_pred_full = predict(X_full_poly, theta, mean_train, std_train) return { 'coefficients': theta, 'train_predictions': y_pred_train, 'test_predictions': y_pred_test, 'full_predictions': y_pred_full, 'train_metrics': train_metrics, 'test_metrics': test_metrics, 'overfitting_gap': overfitting_indicator, 'polynomial_degree': graad, 'feature_means': mean_train, 'feature_stds': std_train } # VOORBEELD GEBRUIK MET MAANDELIJKSE VERKOOPGEGEVENS def voorbeeld_gebruik(): """ Voorbeeld van hoe de functie te gebruiken met synthetische verkoopdata """ # Genereer voorbeeld data (36 maanden = 3 jaar) np.random.seed(42) maanden = np.arange(1, 37) # 36 maanden # Seizoensgebonden verkooppatroon + trend + ruis verkoop = ( 1000 + # basisniveau 50 * maanden + # lineaire trend 200 * np.sin(2 * np.pi * maanden / 12) + # seizoenspatroon np.random.normal(0, 50, len(maanden)) # ruis ) # Voer polynomiale regressie uit resultaat = polynomiale_regressie(maanden, verkoop, graad=2) # Print resultaten print("=== POLYNOMIALE REGRESSIE RESULTATEN ===") print(f"Polynomiale graad: {resultaat['polynomial_degree']}") print(f"\nCoefficienten: {resultaat['coefficients']}") print("\n=== TRAIN SET EVALUATIE ===") for metric, value in resultaat['train_metrics'].items(): print(f"{metric}: {value:.4f}") print("\n=== TEST SET EVALUATIE ===") for metric, value in resultaat['test_metrics'].items(): print(f"{metric}: {value:.4f}") print(f"\nOverfitting indicator (train R² - test R²): {resultaat['overfitting_gap']:.4f}") if resultaat['overfitting_gap'] > 0.1: print("WAARSCHUWING: Mogelijk overfitting gedetecteerd!") else: print("Model lijkt goed te generaliseren.") # Visualisatie plt.figure(figsize=(12, 6)) plt.scatter(maanden, verkoop, alpha=0.7, label='Werkelijke verkoop', color='blue') plt.plot(maanden, resultaat['full_predictions'], label=f'Polynomiale regressie (graad {resultaat["polynomial_degree"]})', color='red', linewidth=2) plt.xlabel('Maanden') plt.ylabel('Verkoopcijfers') plt.title('Polynomiale Regressie - Maandelijkse Verkoopcijfers') plt.legend() plt.grid(True, alpha=0.3) plt.show() return resultaat # Uitvoeren van het voorbeeld if __name__ == "__main__": resultaat = voorbeeld_gebruik() ``` ## Belangrijke Overwegingen en Features: ### 1. **Overfitting Preventie:** - **Train-Test Split**: 80/20 splitsing voor betrouwbare evaluatie - **Regularisatie**: Ridge regression met L2 penalty - **Cross-validatie**: Middels separate train/test sets ### 2. **Model Evaluatie Metrics:** - **R² (Determinatiecoëfficiënt)**: Variantie verklaring - **MSE/RMSE**: Gemiddelde kwadratische fout - **MAE**: Gemiddelde absolute fout - **Overfitting gap**: Verschil tussen train en test R² ### 3. **Numerieke Stabiliteit:** - **Feature normalisatie**: Voorkomt numerieke instabiliteit - **Regularisatie**: Voorkomt extreme coefficientwaarden ### 4. **Gebruiksaanwijzing:** ```python # Voor je eigen data: maanden = np.array([1, 2, 3, ..., 36]) # 36 maanden verkoop = np.array([...]) # Werkelijke verkoopcijfers resultaat = polynomiale_regressie(maanden, verkoop, graad=2) ``` Deze implementatie biedt een robuuste oplossing met aandacht voor overfitting en uitgebreide model evaluatie!