Code Duplication - SimonBlanke/Gradient-Free-Optimizers - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 53-55 lines in 2 locations

src/gradient_free_optimizers/optimizer_search/parallel_tempering.py 1 location


)


class ParallelTemperingOptimizer(_ParallelTemperingOptimizer, Search):
    """
    A class implementing **parallel tempering** for the public API.
    Inheriting from the `Search`-class to get the `search`-method and from
    the `ParallelTemperingOptimizer`-backend to get the underlying algorithm.

    Parameters
    ----------
    search_space : dict[str, list]
        The search space to explore. A dictionary with parameter
        names as keys and a numpy array as values.
    initialize : dict[str, int]
        The method to generate initial positions. A dictionary with
        the following key literals and the corresponding value type:
        {"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
    constraints : list[callable]
        A list of constraints, where each constraint is a callable.
        The callable returns `True` or `False` dependend on the input parameters.
    random_state : None, int
        If None, create a new random state. If int, create a new random state
        seeded with the value.
    rand_rest_p : float
        The probability of a random iteration during the the search process.
    population : int
        The number of simulated annealers in the population.
    n_iter_swap : int
        The number of iterations the algorithm performs before switching temperatures of the individual optimizers in the population.
    """

    def __init__(
        self,
        search_space: Dict[str, list],
        initialize: Dict[
            Literal["grid", "vertices", "random", "warm_start"],
            Union[int, list[dict]],
        ] = {"grid": 4, "random": 2, "vertices": 4},
        constraints: List[callable] = [],
        random_state: int = None,
        rand_rest_p: float = 0,
        nth_process: int = None,
        population: int = 5,
        n_iter_swap: int = 5,
    ):
        super().__init__(
            search_space=search_space,
            initialize=initialize,
            constraints=constraints,
            random_state=random_state,
            rand_rest_p=rand_rest_p,
            nth_process=nth_process,
            population=population,
            n_iter_swap=n_iter_swap,
        )


src/gradient_free_optimizers/optimizer_search/spiral_optimization.py 1 location


from ..optimizers import SpiralOptimization as _SpiralOptimization


class SpiralOptimization(_SpiralOptimization, Search):
    """
    A class implementing the **spiral optimizer** for the public API.
    Inheriting from the `Search`-class to get the `search`-method and from
    the `SpiralOptimization`-backend to get the underlying algorithm.

    Parameters
    ----------
    search_space : dict[str, list]
        The search space to explore. A dictionary with parameter
        names as keys and a numpy array as values.
    initialize : dict[str, int]
        The method to generate initial positions. A dictionary with
        the following key literals and the corresponding value type:
        {"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
    constraints : list[callable]
        A list of constraints, where each constraint is a callable.
        The callable returns `True` or `False` dependend on the input parameters.
    random_state : None, int
        If None, create a new random state. If int, create a new random state
        seeded with the value.
    rand_rest_p : float
        The probability of a random iteration during the the search process.
    population : int
        The number of particles in the swarm.
    decay_rate : float
        This parameter is a factor, that influences the radius of the particles during their spiral movement.
        Lower values accelerates the convergence of the particles to the best known position, while values above 1 eventually lead to a movement where the particles spiral away from each other.
    """

    def __init__(
        self,
        search_space: Dict[str, list],
        initialize: Dict[
            Literal["grid", "vertices", "random", "warm_start"],
            Union[int, list[dict]],
        ] = {"grid": 4, "random": 2, "vertices": 4},
        constraints: List[callable] = [],
        random_state: int = None,
        rand_rest_p: float = 0,
        nth_process: int = None,
        population: int = 10,
        decay_rate: float = 0.99,
    ):
        super().__init__(
            search_space=search_space,
            initialize=initialize,
            constraints=constraints,
            random_state=random_state,
            rand_rest_p=rand_rest_p,
            nth_process=nth_process,
            population=population,
            decay_rate=decay_rate,
        )


		@@ 13-67 (lines=55) @@
10		)
11
12
13		class ParallelTemperingOptimizer(_ParallelTemperingOptimizer, Search):
14		"""
15		A class implementing parallel tempering for the public API.
16		Inheriting from the `Search`-class to get the `search`-method and from
17		the `ParallelTemperingOptimizer`-backend to get the underlying algorithm.
18
19		Parameters
20		----------
21		search_space : dict[str, list]
22		The search space to explore. A dictionary with parameter
23		names as keys and a numpy array as values.
24		initialize : dict[str, int]
25		The method to generate initial positions. A dictionary with
26		the following key literals and the corresponding value type:
27		{"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
28		constraints : list[callable]
29		A list of constraints, where each constraint is a callable.
30		The callable returns `True` or `False` dependend on the input parameters.
31		random_state : None, int
32		If None, create a new random state. If int, create a new random state
33		seeded with the value.
34		rand_rest_p : float
35		The probability of a random iteration during the the search process.
36		population : int
37		The number of simulated annealers in the population.
38		n_iter_swap : int
39		The number of iterations the algorithm performs before switching temperatures of the individual optimizers in the population.
40		"""
41
42		def __init__(
43		self,
44		search_space: Dict[str, list],
45		initialize: Dict[
46		Literal["grid", "vertices", "random", "warm_start"],
47		Union[int, list[dict]],
48		] = {"grid": 4, "random": 2, "vertices": 4},
49		constraints: List[callable] = [],
50		random_state: int = None,
51		rand_rest_p: float = 0,
52		nth_process: int = None,
53		population: int = 5,
54		n_iter_swap: int = 5,
55		):
56		super().__init__(
57		search_space=search_space,
58		initialize=initialize,
59		constraints=constraints,
60		random_state=random_state,
61		rand_rest_p=rand_rest_p,
62		nth_process=nth_process,
63		population=population,
64		n_iter_swap=n_iter_swap,
65		)
66

		@@ 11-63 (lines=53) @@
8		from ..optimizers import SpiralOptimization as _SpiralOptimization
9
10
11		class SpiralOptimization(_SpiralOptimization, Search):
12		"""
13		A class implementing the spiral optimizer for the public API.
14		Inheriting from the `Search`-class to get the `search`-method and from
15		the `SpiralOptimization`-backend to get the underlying algorithm.
16
17		Parameters
18		----------
19		search_space : dict[str, list]
20		The search space to explore. A dictionary with parameter
21		names as keys and a numpy array as values.
22		initialize : dict[str, int]
23		The method to generate initial positions. A dictionary with
24		the following key literals and the corresponding value type:
25		{"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
26		constraints : list[callable]
27		A list of constraints, where each constraint is a callable.
28		The callable returns `True` or `False` dependend on the input parameters.
29		random_state : None, int
30		If None, create a new random state. If int, create a new random state
31		seeded with the value.
32		rand_rest_p : float
33		The probability of a random iteration during the the search process.
34		population : int
35		The number of particles in the swarm.
36		decay_rate : float
37		This parameter is a factor, that influences the radius of the particles during their spiral movement.
38		Lower values accelerates the convergence of the particles to the best known position, while values above 1 eventually lead to a movement where the particles spiral away from each other.
39		"""
40
41		def __init__(
42		self,
43		search_space: Dict[str, list],
44		initialize: Dict[
45		Literal["grid", "vertices", "random", "warm_start"],
46		Union[int, list[dict]],
47		] = {"grid": 4, "random": 2, "vertices": 4},
48		constraints: List[callable] = [],
49		random_state: int = None,
50		rand_rest_p: float = 0,
51		nth_process: int = None,
52		population: int = 10,
53		decay_rate: float = 0.99,
54		):
55		super().__init__(
56		search_space=search_space,
57		initialize=initialize,
58		constraints=constraints,
59		random_state=random_state,
60		rand_rest_p=rand_rest_p,
61		nth_process=nth_process,
62		population=population,
63		decay_rate=decay_rate,
64		)
65

SimonBlanke / Gradient-Free-Optimizers

Code Duplication Length = 53-55 lines in 2 locations

src/gradient_free_optimizers/optimizer_search/parallel_tempering.py 1 location

src/gradient_free_optimizers/optimizer_search/spiral_optimization.py 1 location