As shown in the previous chapters, the model's predictions can vary depending on the value of **k** (the number of neighbors). When building a k-NN model, it's important to choose the k value that gives the **best performance**.

A common approach is to use **cross-validation** to evaluate model performance. You can run a loop and calculate cross-validation scores **for a range of k values**, then select the one with the highest score. This is the most widely used method.

To perform this, `sklearn` offers a convenient tool: the `GridSearchCV` class.


### Constructor:
* `GridSearchCV(estimator, param_grid, scoring, cv = 5)`
    * `estimator` — the model object;
    * `param_grid` — dictionary with parameter values to search through;
    * `scoring` — the metric used for cross-validation score;
    * `cv` — the number of folds (5 by default);

### Methods:
* `fit(X, y)` — train the models using X, y;
* `predict(X)` — predict the class for X;
* `score(X, y)` — returns the accuracy for the X, y set;

### Attributes:
* `best_estimator_` — object of a model with highest score;
* `best_score_` — the score of the `best_estimator_`.

The `param_grid` parameter takes a **dictionary** where the keys are parameter names and the values are lists of options to try. For example, to test values from `1` to `99` for `n_neighbors`, you can write:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Calling the `.fit(X, y)` method on the `GridSearchCV` object will search through the parameter grid to find the best parameters and then **re-train the model on the entire dataset** using those best parameters.

You can access the **best score** using the `.best_score_` attribute and make predictions with the optimized model using the `.predict()` method. Similarly, you can retrieve the **best model** itself using the `.best_estimator_` attribute.

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_param_grid_is_declared(self):
        import user_code

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

    def test_para_grid_is_dict(self):
        import user_code

        try:
            condition = isinstance(user_code.param_grid, dict)
            failure_message = f"Expected `param_grid` to be a `dict`, but got `{type(user_code.param_grid).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `param_grid` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "`param_grid` is a `dict`.",
            failure_message
        )

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'n_neighbors': [3, 9, 18, 27]}

        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_search_is_declared(self):
        import user_code

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

    def test_grid_search_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.neighbors import KNeighborsClassifier

        knn = KNeighborsClassifier()
        param_grid = {'n_neighbors': [3, 9, 18, 27]}

        variable = 'grid_search'
        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, KNeighborsClassifier) and actual_value.param_grid == param_grid and actual_value.cv == 4
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `knn` as the model, `4` folds, and `param_grid` as the grid of parameters, 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_search` is a `GridSearchCV` with `estimator=knn`, `param_grid=param_grid`, and `cv=4`.",
            failure_message
        )

    def test_best_model_is_declared(self):
        import user_code

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

    def test_best_model_is_correct(self):
        import user_code
        from sklearn.neighbors import KNeighborsClassifier

        variable = 'best_model'
        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, KNeighborsClassifier):
            condition = actual_value.n_neighbors == 27
            failure_message = f"Expected `{variable}` to be a `KNeighborsClassifier` with `27` neighbors, but got `n_neighbors={actual_value.n_neighbors}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `KNeighborsClassifier`."

        _dynamic_test(
            self,
            condition,
            "`best_model` is a `KNeighborsClassifier` with `27` neighbors.",
            failure_message
        )

    def test_best_score_is_declared(self):
        import user_code

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

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.8039505464098539

        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 algorithms of supervised learning and implement them using Scikit-learn. Explore linear and polynomial regression for price prediction, and transition into classification using k-NN, Logistic Regression, and Decision Trees. Learn to evaluate models through cross-validation, manage overfitting with regularization, and optimize hyperparameters. Build robust predictive systems and define complex decision boundaries for multi-class classification tasks.

Challenge: Choosing the Best K Value

Constructor:

Methods:

Attributes:

解答