Voor deze uitdaging bouw je dezelfde Polynomial Regression van graad 2 als in de vorige uitdaging. Je moet echter de dataset splitsen in een trainingset en een testset om de RMSE voor beide sets te berekenen. Dit is nodig om te beoordelen of het model overfit of underfit.  
Hier volgt een herinnering aan de `train_test_split()` functie die je wilt gebruiken.

En ook een herinnering aan de `mean_squared_error()` functie met `np.sqrt()` die nodig is om de RMSE te berekenen:
```python
rmse = np.sqrt(mean_squared_error(y_true, y_predicted))
```

import unittest
import numpy as np
import pandas as pd
import statsmodels.api as sm
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import mean_squared_error


# Codefinity helper
def _dynamic_test(test_case, condition, success_msg, fail_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail_msg
        test_case.fail(fail_msg)


class TestUserCode(unittest.TestCase):

    # 1 — X only contains "age"
    def test_X_contains_age(self):
        import user_code

        try:
            X = user_code.X
            condition = list(X.columns) == ["age"]
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "X is correctly assigned from df[['age']].",
            "Expected X = df[['age']]."
        )

    # 2 — PolynomialFeatures applied
    def test_polynomial_features(self):
        import user_code

        try:
            n = user_code.n
            X = user_code.X
            expected = PolynomialFeatures(n).fit_transform(X)
            condition = np.allclose(user_code.X_tilde, expected)
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "PolynomialFeatures applied correctly to X.",
            "Expected X_tilde = PolynomialFeatures(n).fit_transform(X)."
        )

    # 3 — split correctness
    def test_split(self):
        import user_code

        try:
            total = len(user_code.X_tilde)
            condition = (
                len(user_code.X_tilde_train) + len(user_code.X_tilde_test) == total
            )
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "Dataset split correctly.",
            "Expected train_test_split(X_tilde, y, test_size=0.3, random_state=0)."
        )

    # 4 — model is fitted
    def test_model_fitted(self):
        import user_code
        from statsmodels.regression.linear_model import RegressionResultsWrapper

        condition = isinstance(user_code.model, RegressionResultsWrapper)

        _dynamic_test(
            self,
            condition,
            "Model is fitted correctly using OLS.",
            "Expected model = sm.OLS(y_train, X_tilde_train).fit()."
        )

    # 5 — predictions for train and test exist & correct shape
    def test_predictions(self):
        import user_code

        try:
            cond1 = isinstance(user_code.y_train_pred, np.ndarray)
            cond2 = isinstance(user_code.y_test_pred, np.ndarray)
            cond3 = len(user_code.y_train_pred) == len(user_code.y_train)
            cond4 = len(user_code.y_test_pred) == len(user_code.y_test)

            condition = cond1 and cond2 and cond3 and cond4
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "Predictions for train and test sets computed correctly.",
            "Expected model.predict(X_tilde_train/test)."
        )

    # 6 — RMSE computed manually with sqrt(MSE)
    def test_rmse_correct(self):
        import user_code

        try:
            train_expected = np.sqrt(
                mean_squared_error(user_code.y_train, user_code.y_train_pred)
            )
            test_expected = np.sqrt(
                mean_squared_error(user_code.y_test, user_code.y_test_pred)
            )

            condition = (
                np.isclose(train_expected, user_code.train_rmse)
                and np.isclose(test_expected, user_code.test_rmse)
            )
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "RMSE is computed using sqrt(MSE).",
            "Expected RMSE = np.sqrt(mean_squared_error(...))."
        )

    # 7 — summary must be printed
    def test_summary_called(self):
        condition = False
        try:
            with open("user_code.py", "r") as f:
                contents = f.read().replace(" ", "")
            condition = "model.summary()" in contents
        except:
            condition = False

        _dynamic_test(
            self,
            condition,
            "model.summary() is printed.",
            "Expected print(model.summary())."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Wanneer je de taak voltooit, zul je merken dat de test-RMSE zelfs lager is dan de trainings-RMSE. Gewoonlijk laten modellen geen betere resultaten zien op onbekende voorbeelden. Hier is het verschil klein en veroorzaakt door toeval. Onze dataset is relatief klein en bij het splitsen heeft de testset iets betere (makkelijker te voorspellen) datapunten gekregen.

Lineaire regressie is een cruciaal concept binnen voorspellende analyse. Het wordt veel gebruikt door data scientists, data-analisten en statistici omdat het eenvoudig te bouwen en te interpreteren is, maar krachtig genoeg voor veel toepassingen.

Laten we beginnen met het eenvoudigste lineaire regressiemodel. U leert het concept achter lineaire regressie en hoe u voorspellingen kunt doen in Python.

De meeste voorspellingstaken in de praktijk omvatten meer dan één kenmerk. U leert hoe u lineaire regressie met meerdere kenmerken kunt toepassen.

Een rechte lijn beschrijft de data niet altijd goed. Laten we leren hoe we een complexer model voor voorspelling kunnen bouwen. Daarvoor is polynomiale regressie geschikt.

Nu je weet hoe je meerdere lineaire regressiemodellen kunt bouwen, heb je een methode nodig om het beste model te selecteren. Dit is mogelijk met behulp van metrische gegevens. In deze sectie worden de meest gebruikte metrische gegevens en de uitdagingen bij het gebruik ervan toegelicht.

Uitdaging: Prijsvoorspellingen Met Behulp Van Polynomiale Regressie

Oplossing

Awesome!

Uitdaging: Prijsvoorspellingen Met Behulp Van Polynomiale Regressie

Oplossing