Для реалізації логістичної регресії в Python використовується клас `LogisticRegression`:

Наразі можна використовувати параметри за замовчуванням. Створення та навчання моделі виконується одним рядком:

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

Набір даних для цього розділу отримано від **португальської банківської установи** та містить інформацію з маркетингових кампаній, проведених за допомогою телефонних дзвінків. Мета — передбачити, чи підпише клієнт **депозитний договір**, на основі його особистих, фінансових та контактних даних, а також результатів попередніх маркетингових взаємодій.
  
Дані вже попередньо оброблені та готові для подачі в модель.

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

Опануйте основні алгоритми класифікації, що лежать в основі сучасного машинного навчання. Дослідіть, як моделі, такі як k-NN, логістична регресія, дерева рішень і випадкові ліси, здійснюють передбачення, оцінюйте їхню точність і визначайте доцільність використання кожної з них. Розвивайте навички порівняння моделей і вибору найкращої для ваших даних.

Дізнайтеся, як алгоритм k найближчих сусідів здійснює передбачення на основі схожості. Ознайомтеся з обробкою декількох ознак, налаштуванням параметрів і застосуванням крос-валідації для підвищення точності.

Засвоєння принципів моделювання ймовірностей та класифікації результатів за допомогою логістичної регресії. Практика реалізації, інтерпретації меж рішень і застосування регуляризації для запобігання перенавчанню.

Дізнайтеся, як дерева рішень розділяють дані на змістовні групи на основі значень ознак. Дослідіть, як такі параметри, як глибина дерева та мінімальна кількість зразків у листі, впливають на продуктивність моделі та її здатність до узагальнення.

Дослідження того, як випадкові ліси поєднують кілька дерев рішень для підвищення точності та стійкості. Розуміння ролі випадковості та застосування цього ансамблевого методу до реальних даних.

Оцінювання моделей за допомогою метрик, таких як точність, прецизійність, повнота та F1-міра. Вивчення інтерпретації матриць плутанини та порівняння кількох класифікаторів для визначення найефективнішої моделі.

Завдання: Реалізація Логістичної Регресії

Рішення