You will use the following dataset with **two features**:

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
print(df.head())

If you run the code below and take a look at the resulting **scatter plot**, you'll see that the dataset is **not linearly separable**:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
plt.scatter(df['X1'], df['X2'], c=df['y'])
plt.show()

Let's use **cross-validation** to evaluate a simple logistic regression on this data:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
X = df[['X1', 'X2']]
y = df['y']

X = StandardScaler().fit_transform(X)
lr = LogisticRegression().fit(X, y)

y_pred = lr.predict(X)
plt.scatter(df['X1'], df['X2'], c=y_pred)
plt.show()

print(f'Cross-validation accuracy: {cross_val_score(lr, X, y).mean():.2f}')

As you can see, regular Logistic Regression is not suited for this task. Using polynomial regression may help improve the model's performance. Additionally, employing `GridSearchCV` allows you to find the optimal `C` parameter for better accuracy.

This task also uses the `Pipeline` class. You can think of it as a **sequence of preprocessing steps**. Its `.fit_transform()` method sequentially applies `.fit_transform()` to each step in the pipeline.

import typing
import unittest
import importlib


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)


class TestUserCode(unittest.TestCase):

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

    def test_pipe_contains_polynomial_and_scaler(self):
        import user_code
        from sklearn.preprocessing import StandardScaler, PolynomialFeatures
        from sklearn.pipeline import Pipeline

        expected_value = [PolynomialFeatures(include_bias=False), StandardScaler()]

        variable = 'pipe'
        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, Pipeline):
            if isinstance(actual_value.steps, list):
                if len(actual_value.steps) != len(expected_value):
                    failure_message = f'Expected the number of steps of the `pipe` to be `{len(expected_value)}`, but got `{len(actual_value.steps)}`.'
                else:
                    try:
                        steps = [obj for _, obj in actual_value.steps]
                        condition = all(
                            steps[i].get_params() == expected_value[i].get_params() for i in range(len(steps)))
                    except TypeError:
                        steps = actual_value.steps
                        condition = False

                    failure_message = f"Expected the steps of the `{variable}` to be `{expected_value}`, but got `{steps}`."
            else:
                failure_message = "The argument of the `Pipeline` is not a `list`."
        else:
            failure_message = f"`{variable}` is not a `Pipeline`."

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

    def test_param_grid_is_declared(self):
        import user_code

        _dynamic_test(
            self,
            hasattr(user_code, 'param_grid'),
            "The `param_grid` variable is declared.",
            "Expected `param_grid` to be declared."
        )

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'C': [0.01, 0.1, 1, 10, 100]}

        variable = 'param_grid'
        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, dict):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `dict`."

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

    def test_grid_cv_is_declared(self):
        import user_code

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

    def test_grid_cv_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.linear_model import LogisticRegression

        param_grid = {'C': [0.01, 0.1, 1, 10, 100]}

        variable = 'grid_cv'
        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, GridSearchCV):
            condition = isinstance(actual_value.estimator, LogisticRegression) and actual_value.param_grid == param_grid and actual_value.cv is None
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `estimator=LogisticRegression()`, `param_grid={param_grid}`, and `cv=None`, but got `estimator={actual_value.estimator}`, `param_grid={actual_value.param_grid}`, and `cv={actual_value.cv}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `GridSearchCV`."

        _dynamic_test(
            self,
            condition,
            "`grid_cv` is a `GridSearchCV` with `estimator=lr`, `param_grid=param_grid`, and `cv=None`.",
            failure_message
        )

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.9120000000000001

        variable = 'best_score'
        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 contain `{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

Master the core classification algorithms that power modern machine learning. Explore how models like k-NN, logistic regression, decision trees, and random forests make predictions, evaluate their accuracy, and understand when to use each. Build the skills to compare models and choose the best one for your data.

Discover how the k-nearest neighbors algorithm makes predictions based on similarity. Learn to handle multiple features, tune parameters, and apply cross-validation to improve accuracy.

Understand how logistic regression models probabilities and classifies outcomes. Practice implementing it, interpreting decision boundaries, and applying regularization to prevent overfitting.

Learn how decision trees split data into meaningful groups based on feature values. Explore how parameters like tree depth and minimum samples per leaf affect model performance and generalization.

Explore how random forests combine multiple decision trees to improve accuracy and robustness. Understand the role of randomness and apply this ensemble method to real-world data.

Evaluate models using metrics such as accuracy, precision, recall, and F1-score. Learn to interpret confusion matrices and compare multiple classifiers to identify the best-performing model.

Challenge: Classifying Inseparable Data

解答