Logistisen regressiomallin toteuttamiseen Pythonissa käytetään `LogisticRegression`-luokkaa:

Voit toistaiseksi käyttää oletusparametreja. Mallin luominen ja sovittaminen onnistuu yhdellä rivillä:

```python
logistic_regression = LogisticRegression().fit(X_train, y_train)
```

Tämän luvun aineisto on peräisin **portugalilaisesta pankkilaitoksesta** ja sisältää tietoja puhelimitse toteutetuista markkinointikampanjoista. Tavoitteena on ennustaa, **tilaaako asiakas määräaikaistalletuksen**, hyödyntäen hänen henkilökohtaisia, taloudellisia ja yhteystietojaan sekä aiempien markkinointikontaktien tuloksia.
  
Aineisto on jo esikäsitelty ja valmis syötettäväksi mallille.

import unittest
import importlib
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


def get_first_differing_index(expected_array, actual_array):
    for i, (val_1, val_2) in enumerate(zip(expected_array, actual_array)):
        if not np.array_equal(val_1, val_2):
            return i, expected_array[i], actual_array[i]

    if len(expected_array) > len(actual_array):
        return len(actual_array), expected_array[len(actual_array)], None
    else:
        return len(expected_array), None, actual_array[len(expected_array)]


class TestUserCode(unittest.TestCase):

    def test_X_train_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'X_train'),
            "The `X_train` variable is declared.",
            "Expected `X_train` to be declared."
        )

    def test_X_test_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'X_test'),
            "The `X_test` variable is declared.",
            "Expected `X_test` to be declared."
        )

    def test_y_train_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'y_train'),
            "The `y_train` variable is declared.",
            "Expected `y_train` to be declared."
        )

    def test_y_test_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'y_test'),
            "The `y_test` variable is declared.",
            "Expected `y_test` to be declared."
        )

    def test_X_train_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.model_selection import train_test_split

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/marketing_bank.csv')
        X = df.drop('deposit', axis=1).values
        y = df['deposit'].values
        expected_value, _, _, _ = train_test_split(X, y, test_size=0.2, random_state=42)

        variable = 'X_train'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            if actual_value.shape != expected_value.shape:
                failure_message = f"The shape of `{variable}` is incorrect."
            else:
                for i in range(actual_value.shape[0]):
                    if np.array_equal(actual_value[i], expected_value[i]):
                        continue
                    idx, expected_element, actual_element = get_first_differing_index(expected_value[i], actual_value[i])
                    failure_message = f"Expected `{variable}` to contain `{expected_element}` at index [{i}, {idx}], but got `{actual_element}`."
                    break

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_X_test_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.model_selection import train_test_split

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/marketing_bank.csv')
        X = df.drop('deposit', axis=1).values
        y = df['deposit'].values
        _, expected_value, _, _ = train_test_split(X, y, test_size=0.2, random_state=42)

        variable = 'X_test'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            if actual_value.shape != expected_value.shape:
                failure_message = f"The shape of `{variable}` is incorrect."
            else:
                for i in range(actual_value.shape[0]):
                    if np.array_equal(actual_value[i], expected_value[i]):
                        continue
                    idx, expected_element, actual_element = get_first_differing_index(expected_value[i],
                                                                                      actual_value[i])
                    failure_message = f"Expected `{variable}` to contain `{expected_element}` at index [{i}, {idx}], but got `{actual_element}`."
                    break

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_y_train_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.model_selection import train_test_split

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/marketing_bank.csv')
        X = df.drop('deposit', axis=1).values
        y = df['deposit'].values
        _, _, expected_value, _ = train_test_split(X, y, test_size=0.2, random_state=42)

        variable = 'y_train'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_y_test_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.model_selection import train_test_split

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/marketing_bank.csv')
        X = df.drop('deposit', axis=1).values
        y = df['deposit'].values
        _, _, _, expected_value = train_test_split(X, y, test_size=0.2, random_state=42)

        variable = 'y_test'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_lr_is_declared(self):
        import user_code

        variable = 'lr'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_lr_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.linear_model import LogisticRegression
        from sklearn.model_selection import train_test_split

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/marketing_bank.csv')
        X = df.drop('deposit', axis=1)
        y = df['deposit']
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

        expected_value = LogisticRegression().fit(X_train, y_train)

        variable = 'lr'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, LogisticRegression):
            if np.array_equal(actual_value.coef_, expected_value.coef_):
                condition = True
                failure_message = None
            else:
                idx, expected_element, actual_element = get_first_differing_index(expected_value.coef_[0], actual_value.coef_[0])
                failure_message = f"Expected the coefficients of the model to contain `{expected_element}` at index {idx}, but got `{actual_element}`."
        else:
            failure_message = f"`{variable}` is not a `LogisticRegression`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is a correctly fitted `LogisticRegression`.",
            failure_message
        )

    def test_test_accuracy_declared(self):
        import user_code

        variable = 'test_accuracy'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_test_accuracy_is_correct(self):
        import user_code
        expected_value = 0.8083296014330497

        variable = 'test_accuracy'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, float):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to be `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `float`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is correct.",
            failure_message
        )


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

test_main.py

Hallitse keskeiset luokittelualgoritmit, jotka ovat modernin koneoppimisen ytimessä. Tutustu siihen, miten mallit kuten k-NN, logistinen regressio, päätöspuut ja satunnaismetsät tekevät ennusteita, arvioi niiden tarkkuutta ja ymmärrä, milloin kutakin kannattaa käyttää. Kehitä taitoja vertailla malleja ja valita paras vaihtoehto aineistosi perusteella.

Opi, miten k-lähimmän naapurin algoritmi tekee ennusteita samankaltaisuuden perusteella. Sisältää useiden piirteiden käsittelyn, parametrien säätämisen ja ristiinvalidoinnin hyödyntämisen tarkkuuden parantamiseksi.

Ymmärrä, miten logistinen regressio mallintaa todennäköisyyksiä ja luokittelee tuloksia. Harjoittele sen toteuttamista, päätösrajojen tulkintaa sekä regularisoinnin soveltamista ylisovittamisen estämiseksi.

Opi, kuinka päätöspuut jakavat dataa merkityksellisiin ryhmiin ominaisuuksien arvojen perusteella. Tutustu siihen, miten parametrit, kuten puun syvyys ja lehden miniminäytteiden määrä, vaikuttavat mallin suorituskykyyn ja yleistettävyyteen.

Tutustu siihen, miten satunnaismetsät yhdistävät useita päätöspuita parantaakseen tarkkuutta ja vankkuutta. Ymmärrä satunnaisuuden rooli ja sovella tätä yhdistelmämallia reaalimaailman dataan.

Mallien arviointi mittareilla, kuten tarkkuus, precision, recall ja F1-pisteet. Sekamatriksien tulkinta ja useiden luokittelijoiden vertailu parhaan mallin tunnistamiseksi.

Haaste: Logistisen Regressiomallin Toteuttaminen

Ratkaisu