Per questa sfida, costruirai la stessa Regressione Polinomiale di grado 2 come nella sfida precedente. Tuttavia, sarà necessario suddividere il set in un set di addestramento e un set di test per calcolare l'RMSE per entrambi i set. Questo è necessario per valutare se il modello è soggetto a overfitting o underfitting.  
Ecco un promemoria della funzione `train_test_split()` che vorrai utilizzare.

E anche un promemoria della funzione `mean_squared_error()` con `np.sqrt()` necessaria per calcolare l'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

Al termine dell'attività, noterai che l'RMSE sul test è addirittura inferiore a quello sul training. Di solito, i modelli non ottengono risultati migliori su dati non visti. In questo caso, la differenza è minima ed è dovuta al caso. Il nostro dataset è relativamente piccolo e, durante la suddivisione, il set di test ha ricevuto dati leggermente migliori (più facili da prevedere).

La regressione lineare è un concetto fondamentale nell'analisi predittiva. È ampiamente utilizzata da data scientist, analisti di dati e statistici poiché è facile da costruire e interpretare, ma abbastanza potente per molti compiti.

Iniziamo con il modello di Regressione Lineare più semplice. Verranno illustrate le basi della Regressione Lineare e come effettuare previsioni in Python.

La maggior parte delle attività di previsione nel mondo reale coinvolge più di una caratteristica. Verrà illustrato come gestire la regressione lineare con più caratteristiche.

Una retta non descrive sempre adeguatamente i dati. Impariamo come costruire un modello più complesso per la previsione. Questo è l'obiettivo della Regressione Polinomiale.

Ora che sai come costruire diversi modelli di Regressione Lineare, è necessario un metodo per selezionare il migliore. Questo è possibile utilizzando le metriche. Questa sezione illustra le metriche più utilizzate e le difficoltà che si possono incontrare nel loro impiego.

Sfida: Previsione dei Prezzi Tramite Regressione Polinomiale

Soluzione