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

Explores regression techniques for modeling and predicting continuous outcomes using Python. Builds on linear regression foundations to analyze relationships between variables, interpret model coefficients, and evaluate predictive performance on real-world datasets.


Challenge: Evaluating the Model

Ratkaisu

Challenge: Evaluating the Model

Ratkaisu