Seuraavaksi rakennetaan käytännön esimerkki regressiomallista. Käytössäsi on tiedosto `houses_simple.csv`, joka sisältää tietoja asuntojen hinnoista sekä pinta-alasta ominaisuutena.

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

Seuraava vaihe on muuttujien määrittäminen ja aineiston visualisointi:

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

Esimerkissä henkilön pituudesta oli paljon helpompi kuvitella viiva, joka sopii hyvin aineistoon.

Nyt kuitenkin datassamme on huomattavasti enemmän vaihtelua, koska kohdearvo riippuu monista muista tekijöistä, kuten iästä, sijainnista, sisustuksesta jne.
Tehtävänä on kuitenkin rakentaa viiva, joka sopii parhaiten käytettävissä olevaan dataan; se näyttää trendin. Tätä varten tulisi käyttää `OLS`-luokkaa. Pian opimme, miten lisätä enemmän ominaisuuksia, mikä parantaa ennustetta!

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

Lineaarinen regressio on keskeinen käsite ennakoivassa analytiikassa. Sitä käyttävät laajasti data-analyytikot, data scientistit ja tilastotieteilijät, sillä se on helppo rakentaa ja tulkita, mutta riittävän tehokas moniin tehtäviin.

Aloitetaan yksinkertaisimmalla lineaarisen regression mallilla. Opit lineaarisen regression perusidean ja ennusteiden tekemisen Pythonilla.

Useimmat todellisen maailman ennustustehtävät sisältävät useamman kuin yhden muuttujan. Opit käsittelemään lineaarista regressiota useilla muuttujilla.

Suora viiva ei aina kuvaa dataa tarkasti. Opitaan rakentamaan monimutkaisempi malli ennustamista varten. Tätä varten polynominen regressio soveltuu hyvin.

Nyt kun osaat rakentaa useita lineaarisen regressiomalleja, tarvitset tavan valita paras niistä. Tämä on mahdollista mittareiden avulla. Tässä osiossa käsitellään yleisimmin käytettyjä mittareita sekä niihin liittyviä haasteita.

Haaste: Asuntojen Hintojen Ennustaminen

Haaste: Asuntojen Hintojen Ennustaminen

Ratkaisu