NiaPy.algorithms.basic.hho.HarrisHawksOptimization.runIteration() - Code Metrics - Inspection of "Harris Hawks Optimization integration (#280)" - NiaOrg/NiaPy - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d362d8...a0dd78 )

by Grega

created 2020-11-16 07:00 UTC

HarrisHawksOptimization.runIteration() F

↳ Parent: NiaPy.algorithms.basic.hho

Complexity

Conditions

Size

Total Lines	78
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	19
eloc	50
nop	7
dl	0
loc	78
rs	0.5999
c	0
b	0
f	0

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like NiaPy.algorithms.basic.hho.HarrisHawksOptimization.runIteration() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

# encoding=utf8
import logging

from numpy import random as rand, sin, pi, argmin, abs, mean
from scipy.special import gamma

from NiaPy.algorithms.algorithm import Algorithm

logging.basicConfig()
logger = logging.getLogger('NiaPy.algorithms.basic')
logger.setLevel('INFO')

__all__ = ['HarrisHawksOptimization']


class HarrisHawksOptimization(Algorithm):
	r"""Implementation of Harris Hawks Optimization algorithm.

	Algorithm:
				Harris Hawks Optimization

	Date:
				2020

	Authors:
				Francisco Jose Solis-Munoz

	License:
				MIT

	Reference paper:
				Heidari et al. "Harris hawks optimization: Algorithm and applications". Future Generation Computer Systems. 2019. Vol. 97. 849-872.

	Attributes:
				Name (List[str]): List of strings representing algorithm name.
				levy (float): Levy factor.

	See Also:
				* :class:`NiaPy.algorithms.Algorithm`
	"""
	Name = ['HarrisHawksOptimization', 'HHO']

	def __init__(self, **kwargs):
		super(HarrisHawksOptimization, self).__init__(**kwargs)

	@staticmethod
	def algorithmInfo():
		r"""Get algorithms information.

		Returns:
					str: Algorithm information.

		See Also:
					* :func:`NiaPy.algorithms.Algorithm.algorithmInfo`
		"""
		return r"""Heidari et al. "Harris hawks optimization: Algorithm and applications". Future Generation Computer Systems. 2019. Vol. 97. 849-872."""

	@staticmethod
	def typeParameters():
		r"""Return dict with where key of dict represents parameter name and values represent checking functions for selected parameter.

		Returns:
					Dict[str, Callable]:
								* levy (Callable[[Union[float, int]], bool]): Levy factor.

		See Also:
					* :func:`NiaPy.algorithms.Algorithm.typeParameters`
		"""
		d = Algorithm.typeParameters()
		d.update({
				'levy': lambda x: isinstance(x, (float, int)) and x > 0,
		})
		return d

	def setParameters(self, NP=40, levy=0.01, **ukwargs):
		r"""Set the parameters of the algorithm.

		Args:
					levy (Optional[float]): Levy factor.

		See Also:
					* :func:`NiaPy.algorithms.Algorithm.setParameters`
		"""
		Algorithm.setParameters(self, NP=NP, **ukwargs)
		self.levy = levy

	def getParameters(self):
		r"""Get parameters of the algorithm.

		Returns:
					Dict[str, Any]
		"""
		d = Algorithm.getParameters(self)
		d.update({
				'levy': self.levy
		})
		return d

	def initPopulation(self, task, rnd=rand):
		r"""Initialize the starting population.

		Parameters:
					task (Task): Optimization task

		Returns:
					Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
								1. New population.
								2. New population fitness/function values.

		See Also:
					* :func:`NiaPy.algorithms.Algorithm.initPopulation`
		"""
		Sol, Fitness, d = Algorithm.initPopulation(self, task)
		return Sol, Fitness, d

	def levy_function(self, dims, step=0.01, rnd=rand):
		r"""Calculate levy function.

		Parameters:
					dim (int): Number of dimensions
					step (float): Step of the Levy function

		Returns:
					float: The Levy function evaluation
		"""
		beta = 1.5
		sigma = (gamma(1 + beta) * sin(pi * beta / 2) / (gamma((1 + beta / 2) * beta * 2.0 ** ((beta - 1) / 2)))) ** (1 / beta)
		normal_1 = rnd.normal(0, sigma, size=dims)
		normal_2 = rnd.normal(0, 1, size=dims)
		result = step * normal_1 / (abs(normal_2) ** (1 / beta))
		return result

	def runIteration(self, task, Sol, Fitness, xb, fxb, **dparams):
		r"""Core function of Harris Hawks Optimization.

		Parameters:
					task (Task): Optimization task.
					Sol (numpy.ndarray): Current population
					Fitness (numpy.ndarray[float]): Current population fitness/funciton values
					xb (numpy.ndarray): Current best individual
					fxb (float): Current best individual function/fitness value
					dparams (Dict[str, Any]): Additional algorithm arguments

		Returns:
					Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
								1. New population
								2. New population fitness/function vlues
								3. New global best solution
								4. New global best fitness/objective value
		"""
		# Decreasing energy factor
		decreasing_energy_factor = 2 * (1 - task.iters() / task.nGEN)
		mean_sol = mean(Sol)
		# Update population
		for i in range(self.NP):
				jumping_energy = self.Rand.uniform(0, 2)
				decreasing_energy_random = self.Rand.uniform(-1, 1)
				escaping_energy = decreasing_energy_factor * decreasing_energy_random
				escaping_energy_abs = abs(escaping_energy)
				random_number = self.Rand.rand()
				if escaping_energy >= 1 and random_number >= 0.5:
					# 0. Exploration: Random tall tree
					rhi = self.Rand.randint(0, self.NP)
					random_agent = Sol[rhi]
					Sol[i] = random_agent - self.Rand.rand() * abs(random_agent - 2 * self.Rand.rand() * Sol[i])
				elif escaping_energy_abs >= 1 and random_number < 0.5:
					# 1. Exploration: Family members mean
					Sol[i] = (xb - mean_sol) - self.Rand.rand() * self.Rand.uniform(task.Lower, task.Upper)
				elif escaping_energy_abs >= 0.5 and random_number >= 0.5:
					# 2. Exploitation: Soft besiege
					Sol[i] = \
						(xb - Sol[i]) - \
						escaping_energy * \
						abs(jumping_energy * xb - Sol[i])
				elif escaping_energy_abs < 0.5 and random_number >= 0.5:
					# 3. Exploitation: Hard besiege
					Sol[i] = \
						xb - \
						escaping_energy * \
						abs(xb - Sol[i])
				elif escaping_energy_abs >= 0.5 and random_number < 0.5:
					# 4. Exploitation: Soft besiege with pprogressive rapid dives
					cand1 = task.repair(xb - escaping_energy * abs(jumping_energy * xb - Sol[i]), rnd=self.Rand)
					random_vector = self.Rand.rand(task.D)
					cand2 = task.repair(cand1 + random_vector * self.levy_function(task.D, self.levy, rnd=self.Rand), rnd=self.Rand)
					if task.eval(cand1) < Fitness[i]:
						Sol[i] = cand1
					elif task.eval(cand2) < Fitness[i]:
						Sol[i] = cand2
				elif escaping_energy_abs < 0.5 and random_number < 0.5:
					# 5. Exploitation: Hard besiege with progressive rapid dives
					cand1 = task.repair(xb - escaping_energy * abs(jumping_energy * xb - mean_sol), rnd=self.Rand)
					random_vector = self.Rand.rand(task.D)
					cand2 = task.repair(cand1 + random_vector * self.levy_function(task.D, self.levy, rnd=self.Rand), rnd=self.Rand)
					if task.eval(cand1) < Fitness[i]:
						Sol[i] = cand1
					elif task.eval(cand2) < Fitness[i]:
						Sol[i] = cand2
				# Repair agent (from population) values
				Sol[i] = task.repair(Sol[i], rnd=self.Rand)
				# Eval population
				Fitness[i] = task.eval(Sol[i])
		# Get best of population
		best_index = argmin(Fitness)
		xb_cand = Sol[best_index].copy()
		fxb_cand = Fitness[best_index].copy()
		if fxb_cand < fxb:
				fxb = fxb_cand
				xb = xb_cand.copy()
		return Sol, Fitness, xb, fxb, {}

# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3


1			# encoding=utf8
2			import logging
3
4			from numpy import random as rand, sin, pi, argmin, abs, mean
5			from scipy.special import gamma
6
7			from NiaPy.algorithms.algorithm import Algorithm
8
9			logging.basicConfig()
10			logger = logging.getLogger('NiaPy.algorithms.basic')
11			logger.setLevel('INFO')
12
13			__all__ = ['HarrisHawksOptimization']
14
15
16			class HarrisHawksOptimization(Algorithm):
17			r"""Implementation of Harris Hawks Optimization algorithm.
18
19			Algorithm:
20			Harris Hawks Optimization
21
22			Date:
23			2020
24
25			Authors:
26			Francisco Jose Solis-Munoz
27
28			License:
29			MIT
30
31			Reference paper:
32			Heidari et al. "Harris hawks optimization: Algorithm and applications". Future Generation Computer Systems. 2019. Vol. 97. 849-872.
33
34			Attributes:
35			Name (List[str]): List of strings representing algorithm name.
36			levy (float): Levy factor.
37
38			See Also:
39			* :class:`NiaPy.algorithms.Algorithm`
40			"""
41			Name = ['HarrisHawksOptimization', 'HHO']
42
43			def __init__(self, **kwargs):
44			super(HarrisHawksOptimization, self).__init__(**kwargs)
45
46			@staticmethod
47			def algorithmInfo():
48			r"""Get algorithms information.
49
50			Returns:
51			str: Algorithm information.
52
53			See Also:
54			* :func:`NiaPy.algorithms.Algorithm.algorithmInfo`
55			"""
56			return r"""Heidari et al. "Harris hawks optimization: Algorithm and applications". Future Generation Computer Systems. 2019. Vol. 97. 849-872."""
57
58			@staticmethod
59			def typeParameters():
60			r"""Return dict with where key of dict represents parameter name and values represent checking functions for selected parameter.
61
62			Returns:
63			Dict[str, Callable]:
64			* levy (Callable[[Union[float, int]], bool]): Levy factor.
65
66			See Also:
67			* :func:`NiaPy.algorithms.Algorithm.typeParameters`
68			"""
69			d = Algorithm.typeParameters()
70			d.update({
71			'levy': lambda x: isinstance(x, (float, int)) and x > 0,
72			})
73			return d
74
75			def setParameters(self, NP=40, levy=0.01, **ukwargs):
76			r"""Set the parameters of the algorithm.
77
78			Args:
79			levy (Optional[float]): Levy factor.
80
81			See Also:
82			* :func:`NiaPy.algorithms.Algorithm.setParameters`
83			"""
84			Algorithm.setParameters(self, NP=NP, **ukwargs)
85			self.levy = levy
86
87			def getParameters(self):
88			r"""Get parameters of the algorithm.
89
90			Returns:
91			Dict[str, Any]
92			"""
93			d = Algorithm.getParameters(self)
94			d.update({
95			'levy': self.levy
96			})
97			return d
98
99			def initPopulation(self, task, rnd=rand):
100			r"""Initialize the starting population.
101
102			Parameters:
103			task (Task): Optimization task
104
105			Returns:
106			Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
107			1. New population.
108			2. New population fitness/function values.
109
110			See Also:
111			* :func:`NiaPy.algorithms.Algorithm.initPopulation`
112			"""
113			Sol, Fitness, d = Algorithm.initPopulation(self, task)
114			return Sol, Fitness, d
115
116			def levy_function(self, dims, step=0.01, rnd=rand):
117			r"""Calculate levy function.
118
119			Parameters:
120			dim (int): Number of dimensions
121			step (float): Step of the Levy function
122
123			Returns:
124			float: The Levy function evaluation
125			"""
126			beta = 1.5
127			sigma = (gamma(1 + beta) * sin(pi * beta / 2) / (gamma((1 + beta / 2) * beta * 2.0 ((beta - 1) / 2)))) (1 / beta)
128			normal_1 = rnd.normal(0, sigma, size=dims)
129			normal_2 = rnd.normal(0, 1, size=dims)
130			result = step * normal_1 / (abs(normal_2) ** (1 / beta))
131			return result
132
133			def runIteration(self, task, Sol, Fitness, xb, fxb, **dparams):
134			r"""Core function of Harris Hawks Optimization.
135
136			Parameters:
137			task (Task): Optimization task.
138			Sol (numpy.ndarray): Current population
139			Fitness (numpy.ndarray[float]): Current population fitness/funciton values
140			xb (numpy.ndarray): Current best individual
141			fxb (float): Current best individual function/fitness value
142			dparams (Dict[str, Any]): Additional algorithm arguments
143
144			Returns:
145			Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
146			1. New population
147			2. New population fitness/function vlues
148			3. New global best solution
149			4. New global best fitness/objective value
150			"""
151			# Decreasing energy factor
152			decreasing_energy_factor = 2 * (1 - task.iters() / task.nGEN)
153			mean_sol = mean(Sol)
154			# Update population
155			for i in range(self.NP):
156			jumping_energy = self.Rand.uniform(0, 2)
157			decreasing_energy_random = self.Rand.uniform(-1, 1)
158			escaping_energy = decreasing_energy_factor * decreasing_energy_random
159			escaping_energy_abs = abs(escaping_energy)
160			random_number = self.Rand.rand()
161			if escaping_energy >= 1 and random_number >= 0.5:
162			# 0. Exploration: Random tall tree
163			rhi = self.Rand.randint(0, self.NP)
164			random_agent = Sol[rhi]
165			Sol[i] = random_agent - self.Rand.rand() * abs(random_agent - 2 * self.Rand.rand() * Sol[i])
166			elif escaping_energy_abs >= 1 and random_number < 0.5:
167			# 1. Exploration: Family members mean
168			Sol[i] = (xb - mean_sol) - self.Rand.rand() * self.Rand.uniform(task.Lower, task.Upper)
169			elif escaping_energy_abs >= 0.5 and random_number >= 0.5:
170			# 2. Exploitation: Soft besiege
171			Sol[i] = \
172			(xb - Sol[i]) - \
173			escaping_energy * \
174			abs(jumping_energy * xb - Sol[i])
175			elif escaping_energy_abs < 0.5 and random_number >= 0.5:
176			# 3. Exploitation: Hard besiege
177			Sol[i] = \
178			xb - \
179			escaping_energy * \
180			abs(xb - Sol[i])
181			elif escaping_energy_abs >= 0.5 and random_number < 0.5:
182			# 4. Exploitation: Soft besiege with pprogressive rapid dives
183			cand1 = task.repair(xb - escaping_energy * abs(jumping_energy * xb - Sol[i]), rnd=self.Rand)
184			random_vector = self.Rand.rand(task.D)
185			cand2 = task.repair(cand1 + random_vector * self.levy_function(task.D, self.levy, rnd=self.Rand), rnd=self.Rand)
186			if task.eval(cand1) < Fitness[i]:
187			Sol[i] = cand1
188			elif task.eval(cand2) < Fitness[i]:
189			Sol[i] = cand2
190			elif escaping_energy_abs < 0.5 and random_number < 0.5:
191			# 5. Exploitation: Hard besiege with progressive rapid dives
192			cand1 = task.repair(xb - escaping_energy * abs(jumping_energy * xb - mean_sol), rnd=self.Rand)
193			random_vector = self.Rand.rand(task.D)
194			cand2 = task.repair(cand1 + random_vector * self.levy_function(task.D, self.levy, rnd=self.Rand), rnd=self.Rand)
195			if task.eval(cand1) < Fitness[i]:
196			Sol[i] = cand1
197			elif task.eval(cand2) < Fitness[i]:
198			Sol[i] = cand2
199			# Repair agent (from population) values
200			Sol[i] = task.repair(Sol[i], rnd=self.Rand)
201			# Eval population
202			Fitness[i] = task.eval(Sol[i])
203			# Get best of population
204			best_index = argmin(Fitness)
205			xb_cand = Sol[best_index].copy()
206			fxb_cand = Fitness[best_index].copy()
207			if fxb_cand < fxb:
208			fxb = fxb_cand
209			xb = xb_cand.copy()
210			return Sol, Fitness, xb, fxb, {}
211
212			# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3
213

NiaOrg / NiaPy

Push — master ( d362d8...a0dd78 )

HarrisHawksOptimization.runIteration() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like