Voor het implementeren van Logistic Regression in Python wordt de `LogisticRegression`-klasse gebruikt:

Voor nu kunnen de standaardparameters worden aangehouden. Het aanmaken en trainen van het model kan in één regel worden uitgevoerd:

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

De dataset voor dit hoofdstuk is afkomstig van een **Portugese bankinstelling** en bevat informatie uit marketingcampagnes die via telefoongesprekken zijn uitgevoerd. Het doel is om te voorspellen of een klant zich zal **abonneren op een termijndeposito**, op basis van persoonlijke, financiële en contactgerelateerde gegevens, evenals de uitkomsten van eerdere marketinginteracties.
  
De gegevens zijn al voorbewerkt en klaar om aan het model te worden aangeboden.

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

Beheers de kernclassificatie-algoritmen die moderne machine learning aandrijven. Ontdek hoe modellen zoals k-NN, logistische regressie, beslissingsbomen en random forests voorspellingen doen, hun nauwkeurigheid evalueren en begrijp wanneer elk model te gebruiken. Ontwikkel vaardigheden om modellen te vergelijken en de beste keuze te maken voor uw data.

Ontdek hoe het k-nearest neighbors-algoritme voorspellingen doet op basis van gelijkenis. Leer omgaan met meerdere kenmerken, parameters afstemmen en kruisvalidatie toepassen om de nauwkeurigheid te verbeteren.

Inzicht in hoe logistische regressie waarschijnlijkheden modelleert en uitkomsten classificeert. Oefenen met het implementeren ervan, het interpreteren van beslissingsgrenzen en het toepassen van regularisatie om overfitting te voorkomen.

Leer hoe beslisbomen gegevens opdelen in betekenisvolle groepen op basis van kenmerkwaarden. Ontdek hoe parameters zoals boomdiepte en het minimum aantal monsters per blad de modelprestaties en generalisatie beïnvloeden.

Ontdek hoe random forests meerdere beslissingsbomen combineren om de nauwkeurigheid en robuustheid te verbeteren. Begrijp de rol van willekeur en pas deze ensemblemethode toe op real-world data.

Modellen evalueren met behulp van metriek zoals nauwkeurigheid, precisie, recall en F1-score. Interpretatie van verwarringsmatrices en vergelijking van meerdere classificatie-algoritmen om het best presterende model te identificeren.

Uitdaging: Implementatie van Logistische Regressie

Oplossing

Awesome!

Uitdaging: Implementatie van Logistische Regressie

Oplossing