`RandomizedSearchCV` works like `GridSearchCV`, but instead of checking **every** hyperparameter combination, it evaluates a **random subset**.
In the example below, the grid contains 100 combinations. `GridSearchCV` tests all of them, while `RandomizedSearchCV` can sample, for example, 20 — controlled by `n_iter`. This makes tuning **faster**, while usually finding a score close to the best.

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

Try running the code multiple times. `RandomizedSearchCV` may match the grid search score when it randomly samples the **best** hyperparameters.


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

Challenge: Tuning Hyperparameters with RandomizedSearchCV

Solution