In this challenge, you are given the good old housing dataset, but this time only with the `'age'` feature.

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b22d1166-efda-45e8-979e-6c3ecfc566fc/houses_poly.csv')
print(df.head())

Next, we'll create a scatterplot for this data:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b22d1166-efda-45e8-979e-6c3ecfc566fc/houses_poly.csv')
X = df['age']
y = df['price']
plt.scatter(X, y, alpha=0.4)
plt.show()

A straight line is a poor fit here: prices rise for both very new and very old houses. A parabola models this trend better — that’s what you will build in this challenge.

But before you start, recall the `PolynomialFeatures` class.

`fit_transform(X)` needs a 2-D array or DataFrame. Use `df[['col']]` or, for a 1-D array, apply `.reshape(-1, 1)` to convert it into 2-D.


The task is to build a Polynomial Regression of degree 2 using `PolynomialFeatures` and `OLS`.

import unittest
import numpy as np
import pandas as pd
import statsmodels.api as sm
from sklearn.preprocessing import PolynomialFeatures


# Codefinity helper for dynamic names
def _dynamic_test(test_case, condition, ok_msg, fail_msg):
    if condition:
        test_case._testMethodName = ok_msg
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail_msg
        test_case.fail(fail_msg)


class TestUserCode(unittest.TestCase):

    # 1. X contains only "age"
    def test_X_contains_age(self):
        import user_code

        cond = False
        try:
            X = user_code.X
            cond = isinstance(X, pd.DataFrame) and list(X.columns) == ["age"]
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X is correctly assigned from the 'age' column.",
            "Expected X = df[['age']]."
        )

    # 2. PolynomialFeatures used to create X_tilde
    def test_X_tilde_polynomial_preprocessing(self):
        import user_code

        cond = False
        try:
            X = user_code.X
            n = user_code.n
            X_tilde = user_code.X_tilde

            expected = PolynomialFeatures(n).fit_transform(X)

            cond = (
                isinstance(X_tilde, np.ndarray)
                and X_tilde.shape == expected.shape
                and np.allclose(X_tilde, expected)
            )
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_tilde is correctly generated using PolynomialFeatures.",
            "Expected X_tilde = PolynomialFeatures(n).fit_transform(X)."
        )

    # 3. Model is fitted using sm.OLS
    def test_model_fitted(self):
        import user_code
        from statsmodels.regression.linear_model import RegressionResultsWrapper

        cond = isinstance(user_code.model, RegressionResultsWrapper)

        _dynamic_test(
            self,
            cond,
            "The model is correctly fitted using sm.OLS.",
            "Expected model = sm.OLS(y, X_tilde).fit()."
        )

    # 4. X_new reshaped to 2D array via reshape(-1,1)
    def test_X_new_shape(self):
        import user_code

        cond = False
        try:
            X_new = user_code.X_new
            cond = isinstance(X_new, np.ndarray) and len(X_new.shape) == 2 and X_new.shape[1] == 1
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_new is correctly reshaped to (-1, 1).",
            "Expected X_new = np.linspace(...).reshape(-1, 1)."
        )

    # 5. X_new_tilde preprocessed with PolynomialFeatures(n)
    def test_X_new_tilde_polynomial(self):
        import user_code

        cond = False
        try:
            n = user_code.n
            X_new = user_code.X_new
            X_new_tilde = user_code.X_new_tilde

            expected = PolynomialFeatures(n).fit_transform(X_new)

            cond = (
                isinstance(X_new_tilde, np.ndarray)
                and X_new_tilde.shape == expected.shape
                and np.allclose(X_new_tilde, expected)
            )
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_new_tilde is correctly processed using PolynomialFeatures.",
            "Expected X_new_tilde = PolynomialFeatures(n).fit_transform(X_new)."
        )

    # 6. model.params exists and is printed in student code
    def test_model_params_printed(self):
        cond = False
        try:
            with open("user_code.py", "r") as f:
                src = f.read().replace(" ", "")
            cond = "model.params" in src
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Model parameters are printed using model.params.",
            "Expected print(model.params)."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Linear Regression is a crucial concept in predictive analytics. It is widely used by data scientists, data analytics, and statisticians as it is easy to build and interpret but powerful enough for many tasks.

Let's start with the simplest Linear Regression model! You will learn the idea behind Linear Regression and how to make predictions in Python.

Most real-world prediction tasks involve more than one feature. You will learn how to handle Linear Regression with multiple features.

A straight line does not always describe the data well. Let's learn how to build a more complex model for prediction! That's what the Polynomial Regression is suited for.

Now that you know how to build many Linear Regression models, you need a way to choose the best one. This is achievable using metrics. This section explains the most used ones and the difficulties you can face using them.

Challenge: Evaluating the Model

Solution

Challenge: Evaluating the Model

Solution