





import math







class     lowerCamelCase:
     '''simple docstring'''


     def __init__(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         UpperCamelCase__    =       x
         UpperCamelCase__    =       y
         UpperCamelCase__    =       step_size
         UpperCamelCase__    =       function_to_optimize




     def 					lowerCAmelCase__		(						self       ):
         return self.function(self.x							,    self.y       )




     def 					lowerCAmelCase__		(						self       ):
         UpperCamelCase__    =       self.step_size
         return [
             SearchProblem(snake_case_							,    snake_case_							,    snake_case_							,    self.function       )
             for x, y in (
                 (self.x - step_size, self.y - step_size),
                 (self.x - step_size, self.y),
                 (self.x - step_size, self.y + step_size),
                 (self.x, self.y - step_size),
                 (self.x, self.y + step_size),
                 (self.x + step_size, self.y - step_size),
                 (self.x + step_size, self.y),
                 (self.x + step_size, self.y + step_size),
             )
         ]




     def __hash__(						self       ):
         return hash(str(self       )       )




     def __eq__(						self							,    snake_case_       ):
         if isinstance(snake_case_							,    snake_case_       ):
             return hash(str(self       )       ) == hash(str(snake_case_       )       )
         return False




     def __str__(						self       ):
         return F"x: {self.x} y: {self.y}"





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE = True       ,    _SCREAMING_SNAKE_CASE = math.inf       ,    _SCREAMING_SNAKE_CASE = -math.inf       ,    _SCREAMING_SNAKE_CASE = math.inf       ,    _SCREAMING_SNAKE_CASE = -math.inf       ,    _SCREAMING_SNAKE_CASE = False       ,    _SCREAMING_SNAKE_CASE = 10_000       ,    )       ->   SearchProblem:




    """simple docstring"""




    UpperCamelCase__    =       search_prob
    UpperCamelCase__    =       []  # list to store the current score at each iteration
    UpperCamelCase__    =       0
    UpperCamelCase__    =       False
    UpperCamelCase__    =       set()
    while not solution_found and iterations < max_iter:
        visited.add(_SCREAMING_SNAKE_CASE							)
        iterations += 1
        UpperCamelCase__    =       current_state.score()
        scores.append(_SCREAMING_SNAKE_CASE							)
        UpperCamelCase__    =       current_state.get_neighbors()
        UpperCamelCase__    =       -math.inf
        UpperCamelCase__    =       math.inf
        UpperCamelCase__    =       None  # to hold the next best neighbor
        for neighbor in neighbors:
            if neighbor in visited:
                continue  # do not want to visit the same state again
            if (
                neighbor.x > max_x
                or neighbor.x < min_x
                or neighbor.y > max_y
                or neighbor.y < min_y
            ):
                continue  # neighbor outside our bounds
            UpperCamelCase__    =       neighbor.score() - current_score
            if find_max:  # finding max
                # going to direction with greatest ascent
                if change > max_change and change > 0:
                    UpperCamelCase__    =       change
                    UpperCamelCase__    =       neighbor
            else:  # finding min
                # to direction with greatest descent
                if change < min_change and change < 0:
                    UpperCamelCase__    =       change
                    UpperCamelCase__    =       neighbor
        if next_state is not None:
            # we found at least one neighbor which improved the current state
            UpperCamelCase__    =       next_state
        else:
            # since we have no neighbor that improves the solution we stop the search
            UpperCamelCase__    =       True

    if visualization:
        from matplotlib import pyplot as plt

        plt.plot(range(_SCREAMING_SNAKE_CASE							)       ,    _SCREAMING_SNAKE_CASE							)
        plt.xlabel('Iterations'							)
        plt.ylabel('Function values'							)
        plt.show()

    return current_state


if __name__ == "__main__":
 import doctest

 doctest.testmod()





 def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE							)       ->   Union[str, Any]:




     """simple docstring"""




     return (x**2) + (y**2)

 # starting the problem with initial coordinates (3, 4)
 __A       : List[Any]						    = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
 __A       : Union[str, Any]						    = hill_climbing(prob, find_max=False)
 print(
     "The minimum score for f(x, y) = x^2 + y^2 found via hill climbing: "
     f"{local_min.score()}"
 )

 # starting the problem with initial coordinates (12, 47)
 __A       : List[Any]						    = SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
 __A       : Union[str, Any]						    = hill_climbing(
     prob, find_max=False, max_x=100, min_x=5, max_y=50, min_y=-5, visualization=True
 )
 print(
     "The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 "
     f"and 50 > y > - 5 found via hill climbing: {local_min.score()}"
 )





 def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE							)       ->   List[str]:




     """simple docstring"""




     return (3 * x**2) - (6 * y)

 __A       : str						    = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
 __A       : List[Any]						    = hill_climbing(prob, find_max=True)



 print(
     "The maximum score for f(x, y) = x^2 + y^2 found via hill climbing: "
     f"{local_min.score()}"
 )












from sklearn.metrics import accuracy_score

import datasets


__A       : Union[str, Any]						    = "\nAccuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:\nAccuracy = (TP + TN) / (TP + TN + FP + FN)\n Where:\nTP: True positive\nTN: True negative\nFP: False positive\nFN: False negative\n"


__A       : List[Any]						    = "\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.\n\nExamples:\n\n    Example 1-A simple example\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])\n        >>> print(results)\n        {'accuracy': 0.5}\n\n    Example 2-The same as Example 1, except with `normalize` set to `False`.\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)\n        >>> print(results)\n        {'accuracy': 3.0}\n\n    Example 3-The same as Example 1, except with `sample_weight` set.\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])\n        >>> print(results)\n        {'accuracy': 0.8778625954198473}\n"


__A       : List[str]						    = "\n@article{scikit-learn,\n  title={Scikit-learn: Machine Learning in {P}ython},\n  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n  journal={Journal of Machine Learning Research},\n  volume={12},\n  pages={2825--2830},\n  year={2011}\n}\n"







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,   _KWARGS_DESCRIPTION  )
class     lowerCamelCase(	datasets.Metric  ):
     '''simple docstring'''


     def 					lowerCAmelCase__		(						self       ):
         return datasets.MetricInfo(
             description=_DESCRIPTION							,    citation=_CITATION							,    inputs_description=_KWARGS_DESCRIPTION							,    features=datasets.Features(
                 {
                     'predictions': datasets.Sequence(datasets.Value('int32'       )       ),
                     'references': datasets.Sequence(datasets.Value('int32'       )       ),
                 }
                 if self.config_name == 'multilabel'
                 else {
                     'predictions': datasets.Value('int32'       ),
                     'references': datasets.Value('int32'       ),
                 }       )							,    reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html']							,    )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_=True							,    snake_case_=None       ):
         return {
             "accuracy": float(
                 accuracy_score(snake_case_							,    snake_case_							,    normalize=snake_case_							,    sample_weight=snake_case_       )       )
         }





