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.

import unittest
import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression


# 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 correctly
    def test_X_poly_preprocessing(self):
        import user_code

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

            # Re-create expected transformation
            poly = PolynomialFeatures(n)
            expected = poly.fit_transform(X)

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

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

    # 3. Model is LinearRegression and is fitted
    def test_model_fitted(self):
        import user_code

        cond = False
        try:
            model = user_code.model
            cond = isinstance(model, LinearRegression) and hasattr(model, "coef_")
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "The model is a fitted LinearRegression instance.",
            "Expected model = LinearRegression() and model.fit()."
        )

    # 4. X_new reshaped to 2D array
    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_poly transformed correctly
    def test_X_new_poly_transform(self):
        import user_code

        cond = False
        try:
            X_new = user_code.X_new
            X_new_poly = user_code.X_new_poly
            poly = user_code.poly

            expected = poly.transform(X_new)

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

        _dynamic_test(
            self,
            cond,
            "X_new_poly is correctly transformed using the fitted poly instance.",
            "Expected X_new_poly = poly.transform(X_new)."
        )

    # 6. Check print statements logic (intercept_ and coef_)
    def test_params_printed(self):
        cond = False
        try:
            with open("user_code.py", "r") as f:
                src = f.read().replace(" ", "")
            cond = "model.intercept_" in src and "model.coef_" in src
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Model intercept and coefficients are printed.",
            "Expected printing model.intercept_ and model.coef_."
        )


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

test_code.py

Master the core algorithms of supervised learning and implement them using Scikit-learn. Explore linear and polynomial regression for price prediction, and transition into classification using k-NN, Logistic Regression, and Decision Trees. Learn to evaluate models through cross-validation, manage overfitting with regularization, and optimize hyperparameters. Build robust predictive systems and define complex decision boundaries for multi-class classification tasks.

Challenge: Evaluating the Model

解答