Pour ce défi, construction de la même régression polynomiale de degré 2 que dans le défi précédent. Cependant, il est nécessaire de diviser l'ensemble en un ensemble d'entraînement et un ensemble de test afin de calculer la RMSE pour ces deux ensembles. Ceci est requis pour évaluer si le modèle est en surapprentissage ou en sous-apprentissage.  
Voici un rappel de la fonction `train_test_split()` à utiliser.

Et également un rappel de la fonction `mean_squared_error()` avec `np.sqrt()` nécessaire pour calculer la 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

Lorsque vous terminez la tâche, vous remarquerez que la RMSE du test est même inférieure à celle de l'entraînement. Habituellement, les modèles n'obtiennent pas de meilleurs résultats sur des instances non vues. Ici, la différence est minime et due au hasard. Notre jeu de données est relativement petit et, lors de la séparation, l'ensemble de test a reçu des points de données légèrement meilleurs (plus faciles à prédire).

La régression linéaire est un concept essentiel en analytique prédictive. Elle est largement utilisée par les data scientists, les analystes de données et les statisticiens, car elle est facile à construire et à interpréter tout en étant suffisamment puissante pour de nombreuses tâches.

Commençons par le modèle de régression linéaire le plus simple. Vous découvrirez le principe de la régression linéaire et la réalisation de prédictions en Python.

La plupart des tâches de prédiction réelles impliquent plus d'une variable. Vous apprendrez à gérer la régression linéaire avec plusieurs variables explicatives.

Une droite ne décrit pas toujours correctement les données. Apprenons à construire un modèle plus complexe pour la prédiction. C'est à cela que sert la régression polynomiale.

Maintenant que vous savez construire plusieurs modèles de régression linéaire, il est nécessaire de sélectionner le meilleur. Cela est possible grâce à l'utilisation de métriques. Cette section présente les métriques les plus couramment utilisées ainsi que les difficultés rencontrées lors de leur utilisation.

Défi : Prédire les Prix à l'Aide de la Régression Polynomiale

Défi : Prédire les Prix à l'Aide de la Régression Polynomiale

Solution