Python的高性能进化算法工具箱和框架_Python_下载.zip

# **Geatpy2** The Genetic and Evolutionary Algorithm Toolbox for Python with high performance. [](https://github.com/geatpy-dev/geatpy/actions) [](https://pypi.org/project/geatpy/)   [](https://pypi.python.org/pypi/geatpy) [](https://github.com/geatpy-dev/geatpy/blob/master/LICENSE) [](https://gitter.im/geatpy2/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) ## Introduction * **Website (including documentation)**: http://www.geatpy.com * **Demo** : https://github.com/geatpy-dev/geatpy/tree/master/demo * **Pypi page** : https://pypi.org/project/geatpy/ * **Contact us**: http://geatpy.com/index.php/about/ * **Bug reports**: https://github.com/geatpy-dev/geatpy/issues * **Notice**: http://geatpy.com/index.php/notice/ * **FAQ**: http://geatpy.com/index.php/faq/ The features of Geatpy: * Capability of solving single-objective, multi-objectives, many-objectives and combinatorial optimization problems fast. * A huge number of operators with high performance of evolutionary algorithms (selection, recombination, mutation, migration...). * Support numerous encodings for the chromosome of the population. * Many evolutionary algorithm templates, including GA, DE, ES for single/multi-objective(s) evolution. * Multiple population evolution. * Support polysomy evolution. * Parallelization and distribution of evaluations. * Testbeds containing most common benchmarks functions. * Support tracking analysis of the evolution iteration. * Many evaluation metrics of algorithms. ## Improvement of Geatpy 2.7.0 * Add a new way to define the aim function of the problem. * Support calculating objectives and constraints for the variables of only one individual. * Add a optimize function to do the optimization more convenient. * Add new open-source plotting functions. * Remove the dependency on scipy. * A new and faster core. ## Installation 1.Installing online: pip install geatpy 2.From source: python setup.py install or pip install <filename>.whl **Attention**: Geatpy requires numpy>=1.17.0 and matplotlib>=3.0.0, the installation program won't help you install them so that you have to install both of them by yourselves. ## Versions **Geatpy** must run under **Python**3.5, 3.6, 3.7, 3.8, 3.9, or 3.10 in Windows x32/x64, Linux x64 or MacOS x64. There are different versions for **Windows**, **Linux** and **Mac**, you can download them from http://geatpy.com/ The version of **Geatpy** on github is the latest version suitable for **Python** >= 3.5 You can also **update** Geatpy by executing the command: pip install --upgrade geatpy If something wrong happened, such as decoding error about 'utf8' of pip, run this command instead or execute it as an administrator: pip install --upgrade --user geatpy Quick start ----------- Here is the UML figure of Geatpy2.  For solving a multi-objective optimization problem, you can use **Geatpy** mainly in two steps: 1.Write down the aim function and some relevant settings in a derivative class named **MyProblem**, which is inherited from **Problem** class: ```python """MyProblem.py""" import numpy as np import geatpy as ea class MyProblem(ea.Problem): # Inherited from Problem class. def __init__(self, M): # M is the number of objects. name = 'DTLZ1' # Problem's name. maxormins = [1] * M # All objects are need to be minimized. Dim = M + 4 # Set the dimension of decision variables. varTypes = [0] * Dim # Set the types of decision variables. 0 means continuous while 1 means discrete. lb = [0] * Dim # The lower bound of each decision variable. ub = [1] * Dim # The upper bound of each decision variable. lbin = [1] * Dim # Whether the lower boundary is included. ubin = [1] * Dim # Whether the upper boundary is included. # Call the superclass's constructor to complete the instantiation ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin) def aimFunc(self, pop): # Write the aim function here, pop is an object of Population class. Vars = pop.Phen # Get the decision variables XM = Vars[:,(self.M-1):] g = np.array([100 * (self.Dim - self.M + 1 + np.sum(((XM - 0.5)**2 - np.cos(20 * np.pi * (XM - 0.5))), 1))]).T ones_metrix = np.ones((Vars.shape[0], 1)) pop.ObjV = 0.5 * np.fliplr(np.cumprod(np.hstack([ones_metrix, Vars[:,:self.M-1]]), 1)) * np.hstack([ones_metrix, 1 - Vars[:, range(self.M - 2, -1, -1)]]) * np.tile(1 + g, (1, self.M)) def calReferObjV(self): # Calculate the theoretic global optimal solution here. uniformPoint, ans = ea.crtup(self.M, 10000) # create 10000 uniform points. realBestObjV = uniformPoint / 2 return realBestObjV ``` 2.Instantiate **MyProblem** class and a derivative class inherited from **Algorithm** class in a Python script file "main.py" then execute it. **For example**, trying to find the pareto front of **DTLZ1**, do as the following: ```python """main.py""" import geatpy as ea # Import geatpy from MyProblem import MyProblem # Import MyProblem class if __name__ == '__main__': M = 3 # Set the number of objects. problem = MyProblem(M) # Instantiate MyProblem class # Instantiate a algorithm class. algorithm = ea.moea_NSGA3_templet(problem, ea.Population(Encoding='RI', NIND=100), # Set 100 individuals. MAXGEN=500, # Set the max iteration number. logTras=1) # Set the frequency of logging. If it is zero, it would not log. # Do the optimization res = ea.optimize(algorithm, verbose=False, drawing=1, outputMsg=True, drawLog=True, saveFlag=True) ``` Run the "main.py" and the part of the result is:  Execution time: 0.3650233745574951 s Evaluation number: 45500 The number of non-dominated solutions is: 91 gd: 0.00033 igd: 0.02084 hv: 0.84061 spacing: 0.00158 For solving another problem: **Ackley-30D**, which has only one object and 30 decision variables, what you need to do is almost the same as above. 1.Write the aim function in "MyProblem.py". ```python import numpy as np import geatpy as ea class Ackley(ea.Problem): # Inherited from Problem class. def __init__(self, D = 30): name = 'Ackley' # Problem's name. M = 1 # Set the number of objects. maxormins = [1] * M # All objects are need to be minimized. Dim = D # Set the dimension of decision variables. varTypes = [0] * Dim # Set the types of decision variables. 0 means continuous while 1 means discrete. lb = [-32.768] * Dim # The lower bound of each decision variable. ub = [32.768] * Dim # The upper bound of each decision variable. lbin = [1] * Dim # Whether the lower boundary is included. ubin = [1] * Dim # Whether the upper boundary is included. # Call the superclass's constructor to complete the instantiation ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin) def aimFunc(self, pop): # Write the aim function here, pop is an object of Population class. x = pop.Phen # Get the decision variables n = self.Dim f = np.array([-20 * np.exp(-0.2*np.sqrt(1/n*np.sum(x**2, 1))) - np.exp(1/n * np.s