Para este desafío, construirás la misma regresión polinómica de grado 2 que en el desafío anterior. Sin embargo, deberás dividir el conjunto en un conjunto de entrenamiento y un conjunto de prueba para calcular el RMSE en ambos conjuntos. Esto es necesario para evaluar si el modelo está sobreajustado o subajustado.  
Aquí tienes un recordatorio de la función `train_test_split()` que querrás utilizar.

Y también un recordatorio de la función `mean_squared_error()` junto con `np.sqrt()` necesaria para calcular el 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 completar la tarea, notarás que el RMSE de prueba es incluso menor que el RMSE de entrenamiento. Normalmente, los modelos no muestran mejores resultados en instancias no vistas. En este caso, la diferencia es mínima y se debe al azar. Nuestro conjunto de datos es relativamente pequeño y, al dividirlo, el conjunto de prueba recibió algunos puntos de datos un poco mejores (más fáciles de predecir).

La regresión lineal es un concepto fundamental en el análisis predictivo. Es ampliamente utilizada por científicos de datos, analistas de datos y estadísticos, ya que es fácil de construir e interpretar, pero lo suficientemente potente para muchas tareas.

Comencemos con el modelo más sencillo de Regresión Lineal. Aprenderá el concepto fundamental de la Regresión Lineal y cómo realizar predicciones en Python.

La mayoría de las tareas de predicción en el mundo real involucran más de una característica. Aprenderá cómo manejar la regresión lineal con múltiples características.

Una línea recta no siempre describe bien los datos. Aprendamos a construir un modelo más complejo para la predicción. Para esto se utiliza la regresión polinómica.

Ahora que sabes cómo construir varios modelos de Regresión Lineal, necesitas una forma de elegir el mejor. Esto se puede lograr utilizando métricas. Esta sección explica las más utilizadas y las dificultades que puedes encontrar al emplearlas.

Desafío: Predicción de Precios Utilizando Regresión Polinómica

Solución