In dieser Aufgabe soll dasselbe Polynomialregressionsmodell zweiten Grades wie in der vorherigen Aufgabe erstellt werden. Allerdings muss der Datensatz in ein Trainings- und ein Testset aufgeteilt werden, um das RMSE für beide Sets zu berechnen. Dies ist notwendig, um zu beurteilen, ob das Modell über- oder unteranpasst ist.  
Hier eine Erinnerung an die Funktion `train_test_split()`, die verwendet werden sollte.

Außerdem eine Erinnerung an die Funktion `mean_squared_error()` mit `np.sqrt()` zur Berechnung des RMSE:
```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

Nach Abschluss der Aufgabe wird auffallen, dass das Test-RMSE sogar niedriger als das Trainings-RMSE ist. In der Regel zeigen Modelle auf unbekannten Daten keine besseren Ergebnisse. Hier ist der Unterschied jedoch sehr gering und zufallsbedingt. Unser Datensatz ist relativ klein, und beim Aufteilen hat das Testset etwas bessere (leichter vorherzusagende) Datenpunkte erhalten.

Lineare Regression ist ein zentrales Konzept in der prädiktiven Analytik. Sie wird von Data Scientists, Datenanalysten und Statistikern häufig verwendet, da sie einfach zu erstellen und zu interpretieren ist, aber dennoch für viele Aufgaben ausreichend leistungsfähig bleibt.

Beginnen wir mit dem einfachsten Modell der linearen Regression. Sie lernen das Konzept der linearen Regression kennen und erfahren, wie Vorhersagen in Python getroffen werden.

Die meisten Vorhersageaufgaben in der Praxis beinhalten mehr als ein Merkmal. Sie lernen, wie man lineare Regression mit mehreren Merkmalen anwendet.

Eine Gerade beschreibt die Daten nicht immer ausreichend. Lernen Sie, wie ein komplexeres Modell für Vorhersagen erstellt werden kann. Dafür eignet sich die polynomiale Regression.

Nachdem Sie nun wissen, wie man verschiedene lineare Regressionsmodelle erstellt, benötigen Sie eine Methode, um das beste auszuwählen. Dies ist mithilfe von Metriken möglich. In diesem Abschnitt werden die am häufigsten verwendeten Metriken sowie die Herausforderungen bei deren Anwendung erläutert.

Herausforderung: Preisvorhersage Mit Polynomregression

Lösung

Herausforderung: Preisvorhersage Mit Polynomregression

Lösung