In deze uitdaging krijg je de vertrouwde woningendataset, maar dit keer alleen met de eigenschap `'age'`.

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())

Vervolgens maken we een spreidingsdiagram voor deze gegevens:

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()

Een rechte lijn past hier slecht: de prijzen stijgen zowel voor zeer nieuwe als zeer oude huizen. Een parabool modelleert deze trend beter — dat is wat je in deze uitdaging zult bouwen.

Maar voordat je begint, herinner je de `PolynomialFeatures`-klasse.

`fit_transform(X)` vereist een 2D-array of DataFrame. Gebruik `df[['col']]` of, voor een 1D-array, pas `.reshape(-1, 1)` toe om deze om te zetten naar 2D.


De opdracht is het bouwen van een polynomiale regressie van graad 2 met behulp van `PolynomialFeatures` en `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

Lineaire regressie is een cruciaal concept binnen voorspellende analyse. Het wordt veel gebruikt door data scientists, data-analisten en statistici omdat het eenvoudig te bouwen en te interpreteren is, maar krachtig genoeg voor veel toepassingen.

Laten we beginnen met het eenvoudigste lineaire regressiemodel. U leert het concept achter lineaire regressie en hoe u voorspellingen kunt doen in Python.

De meeste voorspellingstaken in de praktijk omvatten meer dan één kenmerk. U leert hoe u lineaire regressie met meerdere kenmerken kunt toepassen.

Een rechte lijn beschrijft de data niet altijd goed. Laten we leren hoe we een complexer model voor voorspelling kunnen bouwen. Daarvoor is polynomiale regressie geschikt.

Nu je weet hoe je meerdere lineaire regressiemodellen kunt bouwen, heb je een methode nodig om het beste model te selecteren. Dit is mogelijk met behulp van metrische gegevens. In deze sectie worden de meest gebruikte metrische gegevens en de uitdagingen bij het gebruik ervan toegelicht.

Uitdaging: Het Model Evalueren

Oplossing