För denna utmaning ska du bygga samma polynomregression av grad 2 som i den föregående utmaningen. Du behöver dock dela upp datamängden i en träningsuppsättning och en testuppsättning för att beräkna RMSE för båda dessa uppsättningar. Detta krävs för att avgöra om modellen överanpassar eller underanpassar.  
Här är en påminnelse om funktionen `train_test_split()` som du kommer att använda.

Och även en påminnelse om funktionen `mean_squared_error()` tillsammans med `np.sqrt()` som behövs för att beräkna 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

När du slutför uppgiften kommer du att märka att test-RMSE är ännu lägre än tränings-RMSE. Vanligtvis visar modeller inte bättre resultat på osedda exempel. Här är skillnaden mycket liten och beror på slumpen. Vårt dataset är relativt litet, och vid uppdelningen fick testuppsättningen något bättre (lättare att förutsäga) datapunkter.

Linjär regression är ett avgörande begrepp inom prediktiv analys. Det används ofta av data scientists, dataanalytiker och statistiker eftersom det är enkelt att bygga och tolka men tillräckligt kraftfullt för många uppgifter.

Vi börjar med den enklaste modellen för linjär regression. Du kommer att lära dig grunderna i linjär regression och hur man gör prediktioner i Python.

De flesta prediktionsuppgifter i verkliga tillämpningar involverar fler än en variabel. Du kommer att lära dig hur man hanterar linjär regression med flera variabler.

En rät linje beskriver inte alltid data på ett tillfredsställande sätt. Lär dig hur du bygger en mer komplex modell för prediktion. Det är vad polynomregression är avsedd för.

Nu när du vet hur man bygger flera linjära regressionsmodeller behöver du ett sätt att välja den bästa. Detta är möjligt med hjälp av metrik. Denna sektion förklarar de mest använda metoderna och de svårigheter du kan stöta på när du använder dem.

Utmaning: Förutsäga Priser med Polynomregression

Utmaning: Förutsäga Priser med Polynomregression

Lösning