The principle of `RandomizedSearchCV` is similar to `GridSearchCV`, but instead of testing every possible combination, it evaluates only a **randomly sampled subset**.

For instance, the following `param_grid` contains 100 combinations:

```python
param_grid = {
    'n_neighbors': [1, 3, 5, 7, 9, 12, 15, 17, 20, 25],
    'weights': ['distance', 'uniform'],
    'p': [1, 2, 3, 4, 5]
}
```

`GridSearchCV` would test all 100, which is **time-consuming**. `RandomizedSearchCV` can instead evaluate a smaller subset, e.g., 20 randomly chosen combinations. This reduces computation time and usually produces results close to the best.

The number of combinations to test is controlled by the `n_iter` argument (default is 10). Other than that, usage is the same as with `GridSearchCV`.


import unittest
import pandas as pd
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)

class TestGridAndRandomizedSearch(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        # ÐÐ°Ð½Ñ Ð· ÑÐ¼Ð¾Ð²Ð¸
        cls.df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a65bbc96-309e-4df9-a790-a1eb8c815a1c/penguins_pipelined.csv'
        )
        cls.X, cls.y = cls.df.drop('species', axis=1), cls.df['species']
        import user_code
        cls.uc = user_code  # Ð¾ÑÑÐºÑÑÑÑÑÑ: randomized, grid, model, param_grid, X, y

    def test_randomizedcv_initialized_with_niter_20(self):
        from sklearn.model_selection import RandomizedSearchCV
        uc = self.uc
        rnd = getattr(uc, 'randomized', None)
        cond = isinstance(rnd, RandomizedSearchCV) and getattr(rnd, 'n_iter', None) == 20
        _dynamic_test(
            self,
            cond,
            "RandomizedSearchCV initialized with n_iter=20",
            "RandomizedSearchCV must be initialized with n_iter=20"
        )

    def test_gridsearchcv_initialized(self):
        from sklearn.model_selection import GridSearchCV
        uc = self.uc
        grd = getattr(uc, 'grid', None)
        cond = isinstance(grd, GridSearchCV)
        _dynamic_test(
            self,
            cond,
            "GridSearchCV initialized with provided param_grid",
            "GridSearchCV must be initialized with provided param_grid"
        )

    def test_param_space_keys(self):
        uc = self.uc
        expected_keys = {'n_neighbors', 'weights', 'p'}
        # Ð£ RandomizedSearchCV Ð¿Ð°ÑÐ°Ð¼ÐµÑÑÐ¸ Ð¼Ð¾Ð¶ÑÑÑ Ð·Ð±ÐµÑÑÐ³Ð°ÑÐ¸ÑÑ ÑÐº param_distributions
        rnd_space = getattr(uc.randomized, 'param_distributions', None)
        grd_space = getattr(uc.grid, 'param_grid', None)
        rnd_ok = isinstance(rnd_space, dict) and set(rnd_space.keys()) == expected_keys
        grd_ok = isinstance(grd_space, dict) and set(grd_space.keys()) == expected_keys
        cond = rnd_ok and grd_ok
        _dynamic_test(
            self,
            cond,
            "Hyperparameter space includes n_neighbors, weights, p for both searches",
            "Hyperparameter space must include n_neighbors, weights, p for both searches"
        )

    def test_estimator_is_knn(self):
        from sklearn.neighbors import KNeighborsClassifier
        uc = self.uc
        is_knn_rnd = isinstance(getattr(uc.randomized, 'estimator', None), KNeighborsClassifier)
        is_knn_grd = isinstance(getattr(uc.grid, 'estimator', None), KNeighborsClassifier)
        cond = is_knn_rnd and is_knn_grd
        _dynamic_test(
            self,
            cond,
            "Both searches use KNeighborsClassifier as estimator",
            "Both searches must use KNeighborsClassifier as estimator"
        )

    def test_both_searches_fitted_and_have_best_attributes(self):
        uc = self.uc
        try:
            attrs_ok = all(
                hasattr(obj, 'best_estimator_') and hasattr(obj, 'best_score_') and hasattr(obj, 'cv_results_')
                for obj in (uc.randomized, uc.grid)
            )
        except Exception:
            attrs_ok = False
        _dynamic_test(
            self,
            attrs_ok,
            "Both searches are fitted (best_estimator_, best_score_, cv_results_ are available)",
            "Both searches must be fitted (best_estimator_, best_score_, cv_results_ must be available)"
        )

    def test_grid_and_randomized_scores_are_finite(self):
        uc = self.uc
        try:
            grid_score = float(uc.grid.best_score_)
            rnd_score = float(uc.randomized.best_score_)
            cond = np.isfinite(grid_score) and np.isfinite(rnd_score)
        except Exception:
            cond = False
        _dynamic_test(
            self,
            cond,
            "Best scores of GridSearchCV and RandomizedSearchCV are finite numbers",
            "Best scores of GridSearchCV and RandomizedSearchCV must be finite numbers"
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

You can try running the code several times. Look at the difference between the two scores. Sometimes the scores can be the same due to the **presence of the best parameters** among combinations sampled by `RandomizedSearchCV`.

Note

Machine learning is now used everywhere. Want to learn it yourself? This course is an introduction to the world of Machine learning for you to learn basic concepts, work with Scikit-learn – the most popular library for ML and build your first Machine Learning project.
This course is intended for students with a basic knowledge of Python, Pandas, and Numpy.

Learn the Machine Learning concepts and the ML project workflow.

Preprocessing is probably the most important stage of an ML project. This chapter covers the preprocessing steps needed for almost any dataset.

A pipeline is a neat way to combine all the preprocessing steps as well as a model. Pipelines make it much easier to train and use a model.

Modeling is the most fun stage of an ML project. Let's learn to build, fine-tune and evaluate the model!

Challenge: Tuning Hyperparameters with RandomizedSearchCV

Solution

Awesome!

Challenge: Tuning Hyperparameters with RandomizedSearchCV

Solution

Awesome!