Ora costruirai un modello di regressione su un esempio reale. Hai a disposizione un file, `houses_simple.csv`, che contiene informazioni sui prezzi delle case con la superficie come caratteristica.

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

Il passo successivo è assegnare le variabili e visualizzare il dataset:

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

Nell'esempio relativo all'altezza di una persona, era molto più semplice immaginare una retta che si adattasse bene ai dati.  

Tuttavia, ora i nostri dati presentano una varianza molto maggiore, poiché il target dipende fortemente da molti altri fattori come età, posizione, interni, ecc.  
In ogni caso, l'obiettivo è costruire la retta che meglio si adatta ai dati disponibili; essa mostrerà la tendenza. Per questo scopo si dovrebbe utilizzare la classe `OLS`. Presto impareremo come aggiungere ulteriori variabili, il che renderà la previsione più accurata!

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

La regressione lineare è un concetto fondamentale nell'analisi predittiva. È ampiamente utilizzata da data scientist, analisti di dati e statistici poiché è facile da costruire e interpretare, ma abbastanza potente per molti compiti.

Iniziamo con il modello di Regressione Lineare più semplice. Verranno illustrate le basi della Regressione Lineare e come effettuare previsioni in Python.

La maggior parte delle attività di previsione nel mondo reale coinvolge più di una caratteristica. Verrà illustrato come gestire la regressione lineare con più caratteristiche.

Una retta non descrive sempre adeguatamente i dati. Impariamo come costruire un modello più complesso per la previsione. Questo è l'obiettivo della Regressione Polinomiale.

Ora che sai come costruire diversi modelli di Regressione Lineare, è necessario un metodo per selezionare il migliore. Questo è possibile utilizzando le metriche. Questa sezione illustra le metriche più utilizzate e le difficoltà che si possono incontrare nel loro impiego.

Sfida: Previsione dei Prezzi delle Case

Soluzione