scikit-opt

Swarm Intelligence in Python
(Genetic Algorithm, Particle Swarm Optimization, Simulated Annealing, Ant Colony Algorithm, Immune Algorithm,Artificial Fish Swarm Algorithm in Python)

• Documentation: https://scikit-opt.github.io/scikit-opt/#/en/
• 文档： https://scikit-opt.github.io/scikit-opt/#/zh/
  
• Source code: https://github.com/guofei9987/scikit-opt
• Help us improve scikit-opt https://www.wjx.cn/jq/50964691.aspx

install

bash pip install scikit-opt

For the current developer version: bach git clone git@github.com:guofei9987/scikit-opt.git cd scikit-opt pip install .

Features

Feature1: UDF

UDF (user defined function) is available now!

For example, you just worked out a new type of selection function.
Now, your selection function is like this:
-> Demo code: examples/demogaudf.py#s1 ```python

step1: define your own operator:

def selectiontournament(algorithm, tournsize): FitV = algorithm.FitV selindex = [] for i in range(algorithm.sizepop): aspirantsindex = np.random.choice(range(algorithm.sizepop), size=tournsize) selindex.append(max(aspirantsindex, key=lambda i: FitV[i])) algorithm.Chrom = algorithm.Chrom[selindex, :] # next generation return algorithm.Chrom

```

Import and build ga
-> Demo code: examples/demogaudf.py#s2 ```python import numpy as np from sko.GA import GA, GA_TSP

demofunc = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + (x[2] - 0.5) ** 2 ga = GA(func=demofunc, ndim=3, sizepop=100, maxiter=500, probmut=0.001, lb=[-1, -10, -5], ub=[2, 10, 2], precision=[1e-7, 1e-7, 1])

Regist your udf to GA -> Demo code: [examples/demo_ga_udf.py#s3](https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_ga_udf.py#L20) python ga.register(operatorname='selection', operator=selectiontournament, tourn_size=3) ```

scikit-opt also provide some operators
-> Demo code: examples/demogaudf.py#s4 ```python from sko.operators import ranking, selection, crossover, mutation

ga.register(operatorname='ranking', operator=ranking.ranking). \ register(operatorname='crossover', operator=crossover.crossover2point). \ register(operatorname='mutation', operator=mutation.mutation) Now do GA as usual -> Demo code: [examples/demo_ga_udf.py#s5](https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_ga_udf.py#L28) python bestx, besty = ga.run() print('bestx:', bestx, '\n', 'besty:', besty) ```

Until Now, the udf surport crossover, mutation, selection, ranking of GA scikit-opt provide a dozen of operators, see here

For advanced users:

-> Demo code: examples/demogaudf.py#s6 ```python class MyGA(GA): def selection(self, tournsize=3): FitV = self.FitV selindex = [] for i in range(self.sizepop): aspirantsindex = np.random.choice(range(self.sizepop), size=tournsize) selindex.append(max(aspirantsindex, key=lambda i: FitV[i])) self.Chrom = self.Chrom[sel_index, :] # next generation return self.Chrom

ranking = ranking.ranking

demofunc = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + (x[2] - 0.5) ** 2 myga = MyGA(func=demofunc, ndim=3, sizepop=100, maxiter=500, lb=[-1, -10, -5], ub=[2, 10, 2], precision=[1e-7, 1e-7, 1]) bestx, besty = myga.run() print('bestx:', bestx, '\n', 'besty:', best_y) ```

feature2: continue to run

(New in version 0.3.6)
Run an algorithm for 10 iterations, and then run another 20 iterations base on the 10 iterations before: ```python from sko.GA import GA

func = lambda x: x[0] ** 2 ga = GA(func=func, n_dim=1) ga.run(10) ga.run(20) ```

feature3: 4-ways to accelerate

• vectorization
• multithreading
• multiprocessing
• cached

see https://github.com/guofei9987/scikit-opt/blob/master/examples/examplefunctionmodes.py

feature4: GPU computation

We are developing GPU computation, which will be stable on version 1.0.0
An example is already available: https://github.com/guofei9987/scikit-opt/blob/master/examples/demogagpu.py

Quick start

1. Differential Evolution

Step1：define your problem
-> Demo code: examples/demo_de.py#s1 ```python ''' min f(x1, x2, x3) = x1^2 + x2^2 + x3^2 s.t. x1x2 >= 1 x1x2 <= 5 x2 + x3 = 1 0 <= x1, x2, x3 <= 5 '''

def obj_func(p): x1, x2, x3 = p return x1 ** 2 + x2 ** 2 + x3 ** 2

constraint_eq = [ lambda x: 1 - x[1] - x[2] ]

constraint_ueq = [ lambda x: 1 - x[0] * x[1], lambda x: x[0] * x[1] - 5 ]

```

Step2: do Differential Evolution
-> Demo code: examples/demo_de.py#s2 ```python from sko.DE import DE

de = DE(func=objfunc, ndim=3, sizepop=50, maxiter=800, lb=[0, 0, 0], ub=[5, 5, 5], constrainteq=constrainteq, constraintueq=constraintueq)

bestx, besty = de.run() print('bestx:', bestx, '\n', 'besty:', besty)

```

2. Genetic Algorithm

Step1：define your problem
-> Demo code: examples/demo_ga.py#s1 ```python import numpy as np

def schaffer(p): ''' This function has plenty of local minimum, with strong shocks global minimum at (0,0) with value 0 https://en.wikipedia.org/wiki/Testfunctionsfor_optimization ''' x1, x2 = p part1 = np.square(x1) - np.square(x2) part2 = np.square(x1) + np.square(x2) return 0.5 + (np.square(np.sin(part1)) - 0.5) / np.square(1 + 0.001 * part2)

```

Step2: do Genetic Algorithm
-> Demo code: examples/demo_ga.py#s2 ```python from sko.GA import GA

ga = GA(func=schaffer, ndim=2, sizepop=50, maxiter=800, probmut=0.001, lb=[-1, -1], ub=[1, 1], precision=1e-7) bestx, besty = ga.run() print('bestx:', bestx, '\n', 'besty:', besty) ```

-> Demo code: examples/demo_ga.py#s3 ```python import pandas as pd import matplotlib.pyplot as plt

Yhistory = pd.DataFrame(ga.allhistoryY) fig, ax = plt.subplots(2, 1) ax[0].plot(Yhistory.index, Yhistory.values, '.', color='red') Yhistory.min(axis=1).cummin().plot(kind='line') plt.show() ```

2.2 Genetic Algorithm for TSP(Travelling Salesman Problem)

Just import the GA_TSP, it overloads the crossover, mutation to solve the TSP

Step1: define your problem. Prepare your points coordinate and the distance matrix.
Here I generate the data randomly as a demo:
-> Demo code: examples/demogatsp.py#s1 ```python import numpy as np from scipy import spatial import matplotlib.pyplot as plt

num_points = 50

pointscoordinate = np.random.rand(numpoints, 2) # generate coordinate of points distancematrix = spatial.distance.cdist(pointscoordinate, points_coordinate, metric='euclidean')

def caltotaldistance(routine): '''The objective function. input routine, return total distance. caltotaldistance(np.arange(numpoints)) ''' numpoints, = routine.shape return sum([distancematrix[routine[i % numpoints], routine[(i + 1) % numpoints]] for i in range(numpoints)])

```

Step2: do GA
-> Demo code: examples/demogatsp.py#s2 ```python

from sko.GA import GA_TSP

gatsp = GATSP(func=caltotaldistance, ndim=numpoints, sizepop=50, maxiter=500, probmut=1) bestpoints, bestdistance = gatsp.run()

```

Step3: Plot the result:
-> Demo code: examples/demogatsp.py#s3 python fig, ax = plt.subplots(1, 2) best_points_ = np.concatenate([best_points, [best_points[0]]]) best_points_coordinate = points_coordinate[best_points_, :] ax[0].plot(best_points_coordinate[:, 0], best_points_coordinate[:, 1], 'o-r') ax[1].plot(ga_tsp.generation_best_Y) plt.show()

3. PSO(Particle swarm optimization)

3.1 PSO

Step1: define your problem:
-> Demo code: examples/demo_pso.py#s1 ```python def demo_func(x): x1, x2, x3 = x return x1 ** 2 + (x2 - 0.05) ** 2 + x3 ** 2

```

Step2: do PSO
-> Demo code: examples/demo_pso.py#s2 ```python from sko.PSO import PSO

pso = PSO(func=demofunc, ndim=3, pop=40, maxiter=150, lb=[0, -1, 0.5], ub=[1, 1, 1], w=0.8, c1=0.5, c2=0.5) pso.run() print('bestx is ', pso.gbestx, 'besty is', pso.gbest_y)

```

Step3: Plot the result
-> Demo code: examples/demo_pso.py#s3 ```python import matplotlib.pyplot as plt

plt.plot(pso.gbestyhist) plt.show() ```

3.2 PSO with nonlinear constraint

If you need nolinear constraint like (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0.5 ** 2<=0
Codes are like this: python constraint_ueq = ( lambda x: (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0.5 ** 2 , ) pso = PSO(func=demo_func, n_dim=2, pop=40, max_iter=max_iter, lb=[-2, -2], ub=[2, 2] , constraint_ueq=constraint_ueq)

Note that, you can add more then one nonlinear constraint. Just add it to constraint_ueq

More over, we have an animation:

↑see examples/demopsoani.py

4. SA(Simulated Annealing)

4.1 SA for multiple function

Step1: define your problem
-> Demo code: examples/demo_sa.py#s1 ```python demo_func = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + x[2] ** 2

**Step2**: do SA -> Demo code: [examples/demo_sa.py#s2](https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_sa.py#L3) python from sko.SA import SA

sa = SA(func=demofunc, x0=[1, 1, 1], Tmax=1, Tmin=1e-9, L=300, maxstaycounter=150) bestx, besty = sa.run() print('bestx:', bestx, 'besty', best_y)

```

Step3: Plot the result
-> Demo code: examples/demo_sa.py#s3 ```python import matplotlib.pyplot as plt import pandas as pd

plt.plot(pd.DataFrame(sa.bestyhistory).cummin(axis=0)) plt.show()

```

Moreover, scikit-opt provide 3 types of Simulated Annealing: Fast, Boltzmann, Cauchy. See more sa

4.2 SA for TSP

Step1: oh, yes, define your problems. To boring to copy this step.

Step2: DO SA for TSP
-> Demo code: examples/demosatsp.py#s2 ```python from sko.SA import SA_TSP

satsp = SATSP(func=caltotaldistance, x0=range(numpoints), Tmax=100, Tmin=1, L=10 * numpoints)

bestpoints, bestdistance = satsp.run() print(bestpoints, bestdistance, caltotaldistance(bestpoints)) ```

Step3: plot the result
-> Demo code: examples/demosatsp.py#s3 ```python from matplotlib.ticker import FormatStrFormatter

fig, ax = plt.subplots(1, 2)

bestpoints = np.concatenate([bestpoints, [bestpoints[0]]]) bestpointscoordinate = pointscoordinate[bestpoints, :] ax[0].plot(satsp.bestyhistory) ax[0].setxlabel("Iteration") ax[0].setylabel("Distance") ax[1].plot(bestpointscoordinate[:, 0], bestpointscoordinate[:, 1], marker='o', markerfacecolor='b', color='c', linestyle='-') ax[1].xaxis.setmajorformatter(FormatStrFormatter('%.3f')) ax[1].yaxis.setmajorformatter(FormatStrFormatter('%.3f')) ax[1].setxlabel("Longitude") ax[1].setylabel("Latitude") plt.show()

```

More: Plot the animation:

↑see examples/demosatsp.py

5. ACA (Ant Colony Algorithm) for tsp

-> Demo code: examples/demoacatsp.py#s2 ```python from sko.ACA import ACA_TSP

aca = ACATSP(func=caltotaldistance, ndim=numpoints, sizepop=50, maxiter=200, distancematrix=distance_matrix)

bestx, besty = aca.run()

```

6. immune algorithm (IA)

-> Demo code: examples/demo_ia.py#s2 ```python

from sko.IA import IA_TSP

iatsp = IATSP(func=caltotaldistance, ndim=numpoints, sizepop=500, maxiter=800, probmut=0.2, T=0.7, alpha=0.95) bestpoints, bestdistance = iatsp.run() print('best routine:', bestpoints, 'bestdistance:', best_distance)

```

7. Artificial Fish Swarm Algorithm (AFSA)

-> Demo code: examples/demo_afsa.py#s1 ```python def func(x): x1, x2 = x return 1 / x1 ** 2 + x1 ** 2 + 1 / x2 ** 2 + x2 ** 2

from sko.AFSA import AFSA

afsa = AFSA(func, ndim=2, sizepop=50, maxiter=300, maxtrynum=100, step=0.5, visual=0.3, q=0.98, delta=0.5) bestx, besty = afsa.run() print(bestx, best_y) ```

Projects using scikit-opt

• Yu, J., He, Y., Yan, Q., & Kang, X. (2021). SpecView: Malware Spectrum Visualization Framework With Singular Spectrum Transformation. IEEE Transactions on Information Forensics and Security, 16, 5093-5107.
• Zhen, H., Zhai, H., Ma, W., Zhao, L., Weng, Y., Xu, Y., ... & He, X. (2021). Design and tests of reinforcement-learning-based optimal power flow solution generator. Energy Reports.
• Heinrich, K., Zschech, P., Janiesch, C., & Bonin, M. (2021). Process data properties matter: Introducing gated convolutional neural networks (GCNN) and key-value-predict attention networks (KVP) for next event prediction with deep learning. Decision Support Systems, 143, 113494.
• Tang, H. K., & Goh, S. K. (2021). A Novel Non-population-based Meta-heuristic Optimizer Inspired by the Philosophy of Yi Jing. arXiv preprint arXiv:2104.08564.
• Wu, G., Li, L., Li, X., Chen, Y., Chen, Z., Qiao, B., ... & Xia, L. (2021). Graph embedding based real-time social event matching for EBSNs recommendation. World Wide Web, 1-22.
• Pan, X., Zhang, Z., Zhang, H., Wen, Z., Ye, W., Yang, Y., ... & Zhao, X. (2021). A fast and robust mixture gases identification and concentration detection algorithm based on attention mechanism equipped recurrent neural network with double loss function. Sensors and Actuators B: Chemical, 342, 129982.
• Castella Balcell, M. (2021). Optimization of the station keeping system for the WindCrete floating offshore wind turbine.
• Zhai, B., Wang, Y., Wang, W., & Wu, B. (2021). Optimal Variable Speed Limit Control Strategy on Freeway Segments under Fog Conditions. arXiv preprint arXiv:2107.14406.
• Yap, X. H. (2021). Multi-label classification on locally-linear data: Application to chemical toxicity prediction.
• Gebhard, L. (2021). Expansion Planning of Low-Voltage Grids Using Ant Colony Optimization Ausbauplanung von Niederspannungsnetzen mithilfe eines Ameisenalgorithmus.
• Ma, X., Zhou, H., & Li, Z. (2021). Optimal Design for Interdependencies between Hydrogen and Power Systems. IEEE Transactions on Industry Applications.
• de Curso, T. D. C. (2021). Estudo do modelo Johansen-Ledoit-Sornette de bolhas financeiras.
• Wu, T., Liu, J., Liu, J., Huang, Z., Wu, H., Zhang, C., ... & Zhang, G. (2021). A Novel AI-based Framework for AoI-optimal Trajectory Planning in UAV-assisted Wireless Sensor Networks. IEEE Transactions on Wireless Communications.
• Liu, H., Wen, Z., & Cai, W. (2021, August). FastPSO: Towards Efficient Swarm Intelligence Algorithm on GPUs. In 50th International Conference on Parallel Processing (pp. 1-10).
• Mahbub, R. (2020). Algorithms and Optimization Techniques for Solving TSP.
• Li, J., Chen, T., Lim, K., Chen, L., Khan, S. A., Xie, J., & Wang, X. (2019). Deep learning accelerated gold nanocluster synthesis. Advanced Intelligent Systems, 1(3), 1900029.