Du skal nu opbygge en regressionsmodel baseret på et virkeligt eksempel. Du har en fil, `houses_simple.csv`, der indeholder information om boligpriser med areal som en egenskab.

import pandas as pd

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

Næste trin er at tildele variabler og visualisere datasættet:

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_simple.csv')
X = df['square_feet']
y = df['price']

plt.scatter(X, y, alpha=0.5)
plt.show()

I eksemplet med en persons højde var det meget lettere at forestille sig en linje, der passer godt til dataene.  

Men nu har vores data meget mere variation, da målet i høj grad afhænger af mange andre faktorer som alder, beliggenhed, indretning osv.  
Opgaven er dog stadig at konstruere den linje, der bedst passer til de data, vi har; den vil vise tendensen. Klassen `OLS` skal anvendes til dette formål. Snart lærer vi, hvordan vi kan tilføje flere funktioner, hvilket vil forbedre forudsigelsen!

import unittest
import importlib
import numpy as np
import pandas as pd
import statsmodels.api as sm


# Helper for dynamic test 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):

    def test_y_is_price(self):
        import user_code

        condition = (
            hasattr(user_code, "y") and
            isinstance(user_code.y, pd.Series) and
            user_code.y.name == "price"
        )

        _dynamic_test(
            self,
            condition,
            "The `y` variable correctly contains the `price` column.",
            "Expected `y` to be assigned as df['price']."
        )

    def test_X_tilde_is_add_constant(self):
        import user_code

        condition = (
            hasattr(user_code, "X_tilde") and
            isinstance(user_code.X_tilde, pd.DataFrame) and
            "const" in user_code.X_tilde.columns
        )

        _dynamic_test(
            self,
            condition,
            "The `X_tilde` matrix is created using sm.add_constant.",
            "Expected `X_tilde` to contain a constant column (using sm.add_constant)."
        )

    def test_regression_model_is_ols(self):
        import user_code
        from statsmodels.regression.linear_model import RegressionResultsWrapper

        condition = (
            hasattr(user_code, "regression_model") and
            isinstance(user_code.regression_model, RegressionResultsWrapper)
        )

        _dynamic_test(
            self,
            condition,
            "The model is an instance of OLS and is fitted.",
            "Expected `regression_model` to be a fitted OLS model."
        )

    def test_X_new_tilde_correct(self):
        import user_code

        condition = (
            hasattr(user_code, "X_new_tilde") and
            hasattr(user_code, "X_new") and
            isinstance(user_code.X_new_tilde, np.ndarray) and
            user_code.X_new_tilde.shape == (3, 2)  # 3 samples + constant
        )

        _dynamic_test(
            self,
            condition,
            "The `X_new_tilde` matrix is correctly created with a constant column.",
            "Expected `X_new_tilde` to be a 2-column array created using sm.add_constant."
        )

    def test_y_pred_is_correct_shape(self):
        import user_code
        import numpy as np

        condition = (
            hasattr(user_code, "y_pred") and
            isinstance(user_code.y_pred, np.ndarray) and
            user_code.y_pred.shape == (3,)
        )

        _dynamic_test(
            self,
            condition,
            "The `y_pred` array has the correct shape (3,).",
            "Expected `y_pred` to be a NumPy array with shape (3,)."
        )

    def test_predict_called(self):
        """
        Checks that the predictions are numbers and reasonable (not NaN or None).
        """
        import user_code
        import numpy as np

        try:
            preds = user_code.y_pred
            condition = (
                isinstance(preds, np.ndarray) and
                np.all(~np.isnan(preds)) and
                preds.size == 3
            )
        except Exception:
            condition = False

        _dynamic_test(
            self,
            condition,
            "The predictions are valid numeric outputs.",
            "Expected `y_pred` to contain valid numeric values."
        )


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


test_code.py

Lineær regression er et centralt begreb inden for prædiktiv analyse. Det anvendes bredt af dataforskere, dataanalytikere og statistikere, da det er let at opbygge og fortolke, men samtidig kraftfuldt nok til mange opgaver.

Lad os begynde med den simpleste lineære regressionsmodel! Du vil lære idéen bag lineær regression og hvordan man foretager forudsigelser i Python.

De fleste virkelige forudsigelsesopgaver involverer mere end én feature. Du vil lære, hvordan man håndterer lineær regression med flere features.

En ret linje beskriver ikke altid dataene tilstrækkeligt. Lad os lære at opbygge en mere kompleks model til forudsigelse. Det er det, polynomiel regression egner sig til.

Nu hvor du ved, hvordan man opbygger flere lineære regressionsmodeller, har du brug for en metode til at vælge den bedste. Dette kan opnås ved hjælp af metrikker. Dette afsnit forklarer de mest anvendte metrikker og de udfordringer, du kan møde ved brugen af dem.

Udfordring: Forudsigelse af Huspriser

Løsning