To implement Logistic Regression in Python, the `LogisticRegression` class is used:

For now, you can stick with the default parameters. Creating and fitting the model can be done in a single line:

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

The dataset for this chapter comes from a **Portuguese banking institution** and contains information from marketing campaigns conducted via phone calls. The goal is to predict whether a client will **subscribe to a term deposit**, based on their personal, financial, and contact-related details, as well as outcomes of previous marketing interactions.
  
The data is already preprocessed and ready to be fed to the model.

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

Introduces classification techniques for predicting categorical outcomes using Python. Focuses on building, training, and evaluating classification models, interpreting decision boundaries, and applying common algorithms to real-world datasets.


Challenge: Implementing Logistic Regression

Lösung

Challenge: Implementing Logistic Regression

Lösung