首先贴上遗传算法代码，如下：
import numpy
import random
import time
import sys
from solution import solution
def crossoverPopulaton(population, scores, popSize, crossoverProbability, keep):
"""
The crossover of all individuals
Parameters
----------
population : list
The list of individuals
scores : list
The list of fitness values for each individual
popSize: int
Number of chrmosome in a population
crossoverProbability: float
The probability of crossing a pair of individuals
keep: int
Number of best individuals to keep without mutating for the next generation
Returns
-------
N/A
"""
# initialize a new population
newPopulation = numpy.empty_like(population)
newPopulation[0:keep] = population[0:keep]
# Create pairs of parents. The number of pairs equals the number of individuals divided by 2
for i in range(keep, popSize, 2):
# pair of parents selection
parent1, parent2 = pairSelection(population, scores, popSize)
crossoverLength = min(len(parent1), len(parent2))
parentsCrossoverProbability = random.uniform(0.0, 1.0)
if parentsCrossoverProbability < crossoverProbability:
offspring1, offspring2 = crossover(crossoverLength, parent1, parent2)
else:
offspring1 = parent1.copy()
offspring2 = parent2.copy()
# Add offsprings to population
newPopulation[i] = numpy.copy(offspring1)
newPopulation[i + 1] = numpy.copy(offspring2)
return newPopulation
def mutatePopulaton(population, popSize, mutationProbability, keep, lb, ub):
"""
The mutation of all individuals
Parameters
----------
population : list
The list of individuals
popSize: int
Number of chrmosome in a population
mutationProbability: float
The probability of mutating an individual
keep: int
Number of best individuals to keep without mutating for the next generation
lb: list
lower bound limit list
ub: list
Upper bound limit list
Returns
-------
N/A
"""
for i in range(keep, popSize):
# Mutation
offspringMutationProbability = random.uniform(0.0, 1.0)
if offspringMutationProbability < mutationProbability:
mutation(population[i], len(population[i]), lb, ub)
def elitism(population, scores, bestIndividual, bestScore):
"""
This melitism operator of the population
Parameters
----------
population : list
The list of individuals
scores : list
The list of fitness values for each individual
bestIndividual : list
An individual of the previous generation having the best fitness value
bestScore : float
The best fitness value of the previous generation
Returns
-------
N/A
"""
# get the worst individual
worstFitnessId = selectWorstIndividual(scores)
# replace worst cromosome with best one from previous generation if its fitness is less than the other
if scores[worstFitnessId] > bestScore:
population[worstFitnessId] = numpy.copy(bestIndividual)
scores[worstFitnessId] = numpy.copy(bestScore)
def selectWorstIndividual(scores):
"""
It is used to get the worst individual in a population based n the fitness value
Parameters
----------
scores : list
The list of fitness values for each individual
Returns
-------
int
maxFitnessId: The individual id of the worst fitness value
"""
maxFitnessId = numpy.where(scores == numpy.max(scores))
maxFitnessId = maxFitnessId[0][0]
return maxFitnessId
def pairSelection(population, scores, popSize):
"""
This is used to select one pair of parents using roulette Wheel Selection mechanism
Parameters
----------
population : list
The list of individuals
scores : list
The list of fitness values for each individual
popSize: int
Number of chrmosome in a population
Returns
-------
list
parent1: The first parent individual of the pair
list
parent2: The second parent individual of the pair
"""
parent1Id = rouletteWheelSelectionId(scores, popSize)
parent1 = population[parent1Id].copy()
parent2Id = rouletteWheelSelectionId(scores, popSize)
parent2 = population[parent2Id].copy()
return parent1, parent2
def rouletteWheelSelectionId(scores, popSize):
"""
A roulette Wheel Selection mechanism for selecting an individual
Parameters
----------
scores : list
The list of fitness values for each individual
popSize: int
Number of chrmosome in a population
Returns
-------
id
individualId: The id of the individual selected
"""
##reverse score because minimum value should have more chance of selection
reverse = max(scores) + min(scores)
reverseScores = reverse - scores.copy()
sumScores = sum(reverseScores)
pick = random.uniform(0, sumScores)
current = 0
for individualId in range(popSize):
current += reverseScores[individualId]
if current > pick:
return individualId
def crossover(individualLength, parent1, parent2):
"""
The crossover operator of a two individuals
Parameters
----------
individualLength: int
The maximum index of the crossover
parent1 : list
The first parent individual of the pair
parent2 : list
The second parent individual of the pair
Returns
-------
list
offspring1: The first updated parent individual of the pair
list
offspring2: The second updated parent individual of the pair
"""
# The point at which crossover takes place between two parents.
crossover_point = random.randint(0, individualLength - 1)
# The new offspring will have its first half of its genes taken from the first parent and second half of its genes taken from the second parent.
offspring1 = numpy.concatenate(
[parent1[0:crossover_point], parent2[crossover_point:]]
)
# The new offspring will have its first half of its genes taken from the second parent and second half of its genes taken from the first parent.
offspring2 = numpy.concatenate(
[parent2[0:crossover_point], parent1[crossover_point:]]
)
return offspring1, offspring2
def mutation(offspring, individualLength, lb, ub):
"""
The mutation operator of a single individual
Parameters
----------
offspring : list
A generated individual after the crossover
individualLength: int
The maximum index of the crossover
lb: list
lower bound limit list
ub: list
Upper bound limit list
Returns
-------
N/A
"""
mutationIndex = random.randint(0, individualLength - 1)
mutationValue = random.uniform(lb[mutationIndex], ub[mutationIndex])
offspring[mutationIndex] = mutationValue
def clearDups(Population, lb, ub):
"""
It removes individuals duplicates and replace them with random ones
Parameters
----------
objf : function
The objective function selected
lb: list
lower bound limit list
ub: list
Upper bound limit list
Returns
-------
list
newPopulation: the updated list of individuals
"""
newPopulation = numpy.unique(Population, axis=0)
oldLen = len(Population)
newLen = len(newPopulation)
if newLen < oldLen:
nDuplicates = oldLen - newLen
newPopulation = numpy.append(
newPopulation,
numpy.random.uniform(0, 1, (nDuplicates, len(Population[0])))
* (numpy.array(ub) - numpy.array(lb))
+ numpy.array(lb),
axis=0,
)
return newPopulation
def calculateCost(objf, population, popSize, lb, ub):
"""
It calculates the fitness value of each individual in the population
Parameters
----------
objf : function
The objective function selected
population : list
The list of individuals
popSize: int
Number of chrmosomes in a population
lb: list
lower bound limit list
ub: list
Upper bound limit list
Returns
-------
list
scores: fitness values of all individuals in the population
"""
scores = numpy.full(popSize, numpy.inf)
# Loop through individuals in population
for i in range(0, popSize):
# Return back the search agents that go beyond the boundaries of the search space
population[i] = numpy.clip(population[i], lb, ub)
# Calculate objective function for each search agent
scores[i] = objf(population[i, :])
return scores
def sortPopulation(population, scores):
"""
This is used to sort the population according to the fitness values of the individuals
Parameters
----------
population : list
The list of individuals
scores : list
The list of fitness values for each individual
Returns
-------
list
population: The new sorted list of individuals
list
scores: The new sorted list of fitness values of the individuals
"""
sortedIndices = scores.argsort()
population = population[sortedIndices]
scores = scores[sortedIndices]
return population, scores
def GA(objf, lb, ub, dim, popSize, iters):
"""
This is the main method which implements GA
Parameters
----------
objf : function
The objective function selected
lb: list
lower bound limit list
ub: list
Upper bound limit list
dim: int
The dimension of the indivisual
popSize: int
Number of chrmosomes in a population
iters: int
Number of iterations / generations of GA
Returns
-------
obj
s: The solution obtained from running the algorithm
"""
cp = 1 # crossover Probability
mp = 0.01 # Mutation Probability
keep = 2
# elitism parameter: how many of the best individuals to keep from one generation to the next
s = solution()
if not isinstance(lb, list):
lb = [lb] * dim
if not isinstance(ub, list):
ub = [ub] * dim
bestIndividual = numpy.zeros(dim)
scores = numpy.random.uniform(0.0, 1.0, popSize)
bestScore = float("inf")
ga = numpy.zeros((popSize, dim))
for i in range(dim):
ga[:, i] = numpy.random.uniform(0, 1, popSize) * (ub[i] - lb[i]) + lb[i]
convergence_curve = numpy.zeros(iters)
print('GA is optimizing "' + objf.__name__ + '"')
timerStart = time.time()
s.startTime = time.strftime("%Y-%m-%d-%H-%M-%S")
for l in range(iters):
# crossover
ga = crossoverPopulaton(ga, scores, popSize, cp, keep)
# mutation
mutatePopulaton(ga, popSize, mp, keep, lb, ub)
ga = clearDups(ga, lb, ub)
scores = calculateCost(objf, ga, popSize, lb, ub)
bestScore = min(scores)
# Sort from best to worst
ga, scores = sortPopulation(ga, scores)
convergence_curve[l] = bestScore
if l % 1 == 0:
print(
[
"At iteration "
+ str(l + 1)
+ " the best fitness is "
+ str(bestScore)
]
)
timerEnd = time.time()
s.bestIndividual = bestIndividual
s.endTime = time.strftime("%Y-%m-%d-%H-%M-%S")
s.executionTime = timerEnd - timerStart
s.convergence = convergence_curve
s.optimizer = "GA"
s.objfname = objf.__name__
return s接下来是粒子群算法，如下：
import random
import numpy
from solution import solution
import time
def PSO(objf, lb, ub, dim, PopSize, iters):
# PSO parameters
Vmax = 6
wMax = 0.9
wMin = 0.2
c1 = 2
c2 = 2
s = solution()
if not isinstance(lb, list):
lb = [lb] * dim
if not isinstance(ub, list):
ub = [ub] * dim
######################## Initializations
vel = numpy.zeros((PopSize, dim))
pBestScore = numpy.zeros(PopSize)
pBestScore.fill(float("inf"))
pBest = numpy.zeros((PopSize, dim))
gBest = numpy.zeros(dim)
gBestScore = float("inf")
pos = numpy.zeros((PopSize, dim))
for i in range(dim):
pos[:, i] = numpy.random.uniform(0, 1, PopSize) * (ub[i] - lb[i]) + lb[i]
convergence_curve = numpy.zeros(iters)
############################################
print('PSO is optimizing "' + objf.__name__ + '"')
timerStart = time.time()
s.startTime = time.strftime("%Y-%m-%d-%H-%M-%S")
for l in range(0, iters):
for i in range(0, PopSize):
# pos[i,:]=checkBounds(pos[i,:],lb,ub)
for j in range(dim):
pos[i, j] = numpy.clip(pos[i, j], lb[j], ub[j])
# Calculate objective function for each particle
fitness = objf(pos[i, :])
if pBestScore[i] > fitness:
pBestScore[i] = fitness
pBest[i, :] = pos[i, :].copy()
if gBestScore > fitness:
gBestScore = fitness
gBest = pos[i, :].copy()
# Update the W of PSO
w = wMax - l * ((wMax - wMin) / iters)
for i in range(0, PopSize):
for j in range(0, dim):
r1 = random.random()
r2 = random.random()
vel[i, j] = (
w * vel[i, j]
+ c1 * r1 * (pBest[i, j] - pos[i, j])
+ c2 * r2 * (gBest[j] - pos[i, j])
)
if vel[i, j] > Vmax:
vel[i, j] = Vmax
if vel[i, j] < -Vmax:
vel[i, j] = -Vmax
pos[i, j] = pos[i, j] + vel[i, j]
convergence_curve[l] = gBestScore
if l % 1 == 0:
print(
[
"At iteration "
+ str(l + 1)
+ " the best fitness is "
+ str(gBestScore)
]
)
timerEnd = time.time()
s.endTime = time.strftime("%Y-%m-%d-%H-%M-%S")
s.executionTime = timerEnd - timerStart
s.convergence = convergence_curve
s.optimizer = "PSO"
s.objfname = objf.__name__
return s最后就是萤火虫算法，如下：
import numpy
import math
import time
from solution import solution
def alpha_new(alpha, NGen):
#% alpha_n=alpha_0(1-delta)^NGen=10^(-4);
#% alpha_0=0.9
delta = 1 - (10 ** (-4) / 0.9) ** (1 / NGen)
alpha = (1 - delta) * alpha
return alpha
def FFA(objf, lb, ub, dim, n, MaxGeneration):
# General parameters
# n=50 #number of fireflies
# dim=30 #dim
# lb=-50
# ub=50
# MaxGeneration=500
# FFA parameters
alpha = 0.5 # Randomness 0--1 (highly random)
betamin = 0.20 # minimum value of beta
gamma = 1 # Absorption coefficient
if not isinstance(lb, list):
lb = [lb] * dim
if not isinstance(ub, list):
ub = [ub] * dim
zn = numpy.ones(n)
zn.fill(float("inf"))
# ns(i,:)=Lb+(Ub-Lb).*rand(1,d);
ns = numpy.zeros((n, dim))
for i in range(dim):
ns[:, i] = numpy.random.uniform(0, 1, n) * (ub[i] - lb[i]) + lb[i]
Lightn = numpy.ones(n)
Lightn.fill(float("inf"))
# [ns,Lightn]=init_ffa(n,d,Lb,Ub,u0)
convergence = []
s = solution()
print('CS is optimizing "' + objf.__name__ + '"')
timerStart = time.time()
s.startTime = time.strftime("%Y-%m-%d-%H-%M-%S")
# Main loop
for k in range(0, MaxGeneration): # start iterations
#% This line of reducing alpha is optional
alpha = alpha_new(alpha, MaxGeneration)
#% Evaluate new solutions (for all n fireflies)
for i in range(0, n):
zn[i] = objf(ns[i, :])
Lightn[i] = zn[i]
# Ranking fireflies by their light intensity/objectives
Lightn = numpy.sort(zn)
Index = numpy.argsort(zn)
ns = ns[Index, :]
# Find the current best
nso = ns
Lighto = Lightn
nbest = ns[0, :]
Lightbest = Lightn[0]
#% For output only
fbest = Lightbest
#% Move all fireflies to the better locations
# [ns]=ffa_move(n,d,ns,Lightn,nso,Lighto,nbest,...
# Lightbest,alpha,betamin,gamma,Lb,Ub);
scale = []
for b in range(dim):
scale.append(abs(ub[b] - lb[b]))
scale = numpy.array(scale)
for i in range(0, n):
# The attractiveness parameter beta=exp(-gamma*r)
for j in range(0, n):
r = numpy.sqrt(numpy.sum((ns[i, :] - ns[j, :]) ** 2))
# r=1
# Update moves
if Lightn[i] > Lighto[j]: # Brighter and more attractive
beta0 = 1
beta = (beta0 - betamin) * math.exp(-gamma * r ** 2) + betamin
tmpf = alpha * (numpy.random.rand(dim) - 0.5) * scale
ns[i, :] = ns[i, :] * (1 - beta) + nso[j, :] * beta + tmpf
# ns=numpy.clip(ns, lb, ub)
convergence.append(fbest)
IterationNumber = k
BestQuality = fbest
if k % 1 == 0:
print(
["At iteration " + str(k) + " the best fitness is " + str(BestQuality)]
)
#
####################### End main loop
timerEnd = time.time()
s.endTime = time.strftime("%Y-%m-%d-%H-%M-%S")
s.executionTime = timerEnd - timerStart
s.convergence = convergence
s.optimizer = "FFA"
s.objfname = objf.__name__
return s运行函数：
from pathlib import Path
import PSO as pso
import FFA as ffa
import GA as ga
import benchmarks
import csv
import numpy
import time
import warnings
import os
import plot_convergence as conv_plot
import plot_boxplot as box_plot
warnings.simplefilter(action="ignore")
def selector(algo, func_details, popSize, Iter):
function_name = func_details[0]
lb = func_details[1]
ub = func_details[2]
dim = func_details[3]
if algo == "PSO":
x = pso.PSO(getattr(benchmarks, function_name), lb, ub, dim, popSize, Iter)
elif algo == "GA":
x = ga.GA(getattr(benchmarks, function_name), lb, ub, dim, popSize, Iter)
elif algo == "FFA":
x = ffa.FFA(getattr(benchmarks, function_name), lb, ub, dim, popSize, Iter)
else:
x = None
return x
def run(optimizer, objectivefunc, NumOfRuns, params, export_flags):
PopulationSize = params["PopulationSize"]
Iterations = params["Iterations"]
# Export results ?
Export = export_flags["Export_avg"]
Export_details = export_flags["Export_details"]
Export_convergence = export_flags["Export_convergence"]
Export_boxplot = export_flags["Export_boxplot"]
Flag = False
Flag_details = False
# CSV Header for for the cinvergence
CnvgHeader = []
results_directory = time.strftime("%Y-%m-%d-%H-%M-%S") + "/"
Path(results_directory).mkdir(parents=True, exist_ok=True)
for l in range(0, Iterations):
CnvgHeader.append("Iter" + str(l + 1))
for i in range(0, len(optimizer)):
for j in range(0, len(objectivefunc)):
convergence = [0] * NumOfRuns
executionTime = [0] * NumOfRuns
for k in range(0, NumOfRuns):
func_details = benchmarks.getFunctionDetails(objectivefunc[j])
x = selector(optimizer[i], func_details, PopulationSize, Iterations)
convergence[k] = x.convergence
optimizerName = x.optimizer
objfname = x.objfname
if Export_details == True:
ExportToFile = results_directory + "experiment_details.csv"
with open(ExportToFile, "a", newline="\n") as out:
writer = csv.writer(out, delimiter=",")
if (
Flag_details == False
): # just one time to write the header of the CSV file
header = numpy.concatenate(
[["Optimizer", "objfname", "ExecutionTime"], CnvgHeader]
)
writer.writerow(header)
Flag_details = True # at least one experiment
executionTime[k] = x.executionTime
a = numpy.concatenate(
[[x.optimizer, x.objfname, x.executionTime], x.convergence]
)
writer.writerow(a)
out.close()
if Export == True:
ExportToFile = results_directory + "experiment.csv"
with open(ExportToFile, "a", newline="\n") as out:
writer = csv.writer(out, delimiter=",")
if (
Flag == False
): # just one time to write the header of the CSV file
header = numpy.concatenate(
[["Optimizer", "objfname", "ExecutionTime"], CnvgHeader]
)
writer.writerow(header)
Flag = True
avgExecutionTime = float("%0.2f" % (sum(executionTime) / NumOfRuns))
avgConvergence = numpy.around(
numpy.mean(convergence, axis=0, dtype=numpy.float64), decimals=2
).tolist()
a = numpy.concatenate(
[[optimizerName, objfname, avgExecutionTime], avgConvergence]
)
writer.writerow(a)
out.close()
if Export_convergence == True:
conv_plot.run(results_directory, optimizer, objectivefunc, Iterations)
if Export_boxplot == True:
box_plot.run(results_directory, optimizer, objectivefunc, Iterations)
if Flag == False: # Faild to run at least one experiment
print(
"No Optomizer or Cost function is selected. Check lists of available optimizers and cost functions"
)
print("Execution completed")function函数：
import numpy
import math
# define the function blocks
def prod(it):
p = 1
for n in it:
p *= n
return p
def Ufun(x, a, k, m):
y = k * ((x - a) ** m) * (x > a) + k * ((-x - a) ** m) * (x < (-a))
return y
def F1(x):
s = numpy.sum(x ** 2)
return s
def F2(x):
o = sum(abs(x)) + prod(abs(x))
return o
def F3(x):
dim = len(x) + 1
o = 0
for i in range(1, dim):
o = o + (numpy.sum(x[0:i])) ** 2
return o
def F4(x):
o = max(abs(x))
return o
def F5(x):
dim = len(x)
o = numpy.sum(
100 * (x[1:dim] - (x[0 : dim - 1] ** 2)) ** 2 + (x[0 : dim - 1] - 1) ** 2
)
return o
def F6(x):
o = numpy.sum(abs((x + 0.5)) ** 2)
return o
def F7(x):
dim = len(x)
w = [i for i in range(len(x))]
for i in range(0, dim):
w[i] = i + 1
o = numpy.sum(w * (x ** 4)) + numpy.random.uniform(0, 1)
return o
def F8(x):
o = sum(-x * (numpy.sin(numpy.sqrt(abs(x)))))
return o
def F9(x):
dim = len(x)
o = numpy.sum(x ** 2 - 10 * numpy.cos(2 * math.pi * x)) + 10 * dim
return o
def F10(x):
dim = len(x)
o = (
-20 * numpy.exp(-0.2 * numpy.sqrt(numpy.sum(x ** 2) / dim))
- numpy.exp(numpy.sum(numpy.cos(2 * math.pi * x)) / dim)
+ 20
+ numpy.exp(1)
)
return o
def F11(x):
dim = len(x)
w = [i for i in range(len(x))]
w = [i + 1 for i in w]
o = numpy.sum(x ** 2) / 4000 - prod(numpy.cos(x / numpy.sqrt(w))) + 1
return o
def F12(x):
dim = len(x)
o = (math.pi / dim) * (
10 * ((numpy.sin(math.pi * (1 + (x[0] + 1) / 4))) ** 2)
+ numpy.sum(
(((x[: dim - 1] + 1) / 4) ** 2)
* (1 + 10 * ((numpy.sin(math.pi * (1 + (x[1 :] + 1) / 4)))) ** 2)
)
+ ((x[dim - 1] + 1) / 4) ** 2
) + numpy.sum(Ufun(x, 10, 100, 4))
return o
def F13(x):
if x.ndim==1:
x = x.reshape(1,-1)
o = 0.1 * (
(numpy.sin(3 * numpy.pi * x[:,0])) ** 2
+ numpy.sum(
(x[:,:-1] - 1) ** 2
* (1 + (numpy.sin(3 * numpy.pi * x[:,1:])) ** 2), axis=1
)
+ ((x[:,-1] - 1) ** 2) * (1 + (numpy.sin(2 * numpy.pi * x[:,-1])) ** 2)
) + numpy.sum(Ufun(x, 5, 100, 4))
return o
def F14(x):
aS = [
[
-32, -16, 0, 16, 32,
-32, -16, 0, 16, 32,
-32, -16, 0, 16, 32,
-32, -16, 0, 16, 32,
-32, -16, 0, 16, 32,
],
[
-32, -32, -32, -32, -32,
-16, -16, -16, -16, -16,
0, 0, 0, 0, 0,
16, 16, 16, 16, 16,
32, 32, 32, 32, 32,
],
]
aS = numpy.asarray(aS)
bS = numpy.zeros(25)
v = numpy.matrix(x)
for i in range(0, 25):
H = v - aS[:, i]
bS[i] = numpy.sum((numpy.power(H, 6)))
w = [i for i in range(25)]
for i in range(0, 24):
w[i] = i + 1
o = ((1.0 / 500) + numpy.sum(1.0 / (w + bS))) ** (-1)
return o
def F15(L):
aK = [
0.1957, 0.1947, 0.1735, 0.16, 0.0844, 0.0627,
0.0456, 0.0342, 0.0323, 0.0235, 0.0246,
]
bK = [0.25, 0.5, 1, 2, 4, 6, 8, 10, 12, 14, 16]
aK = numpy.asarray(aK)
bK = numpy.asarray(bK)
bK = 1 / bK
fit = numpy.sum(
(aK - ((L[0] * (bK ** 2 + L[1] * bK)) / (bK ** 2 + L[2] * bK + L[3]))) ** 2
)
return fit
def F16(L):
o = (
4 * (L[0] ** 2)
- 2.1 * (L[0] ** 4)
+ (L[0] ** 6) / 3
+ L[0] * L[1]
- 4 * (L[1] ** 2)
+ 4 * (L[1] ** 4)
)
return o
def F17(L):
o = (
(L[1] - (L[0] ** 2) * 5.1 / (4 * (numpy.pi ** 2)) + 5 / numpy.pi * L[0] - 6)
** 2
+ 10 * (1 - 1 / (8 * numpy.pi)) * numpy.cos(L[0])
+ 10
)
return o
def F18(L):
o = (
1
+ (L[0] + L[1] + 1) ** 2
* (
19
- 14 * L[0]
+ 3 * (L[0] ** 2)
- 14 * L[1]
+ 6 * L[0] * L[1]
+ 3 * L[1] ** 2
)
) * (
30
+ (2 * L[0] - 3 * L[1]) ** 2
* (
18
- 32 * L[0]
+ 12 * (L[0] ** 2)
+ 48 * L[1]
- 36 * L[0] * L[1]
+ 27 * (L[1] ** 2)
)
)
return o
# map the inputs to the function blocks
def F19(L):
aH = [[3, 10, 30], [0.1, 10, 35], [3, 10, 30], [0.1, 10, 35]]
aH = numpy.asarray(aH)
cH = [1, 1.2, 3, 3.2]
cH = numpy.asarray(cH)
pH = [
[0.3689, 0.117, 0.2673],
[0.4699, 0.4387, 0.747],
[0.1091, 0.8732, 0.5547],
[0.03815, 0.5743, 0.8828],
]
pH = numpy.asarray(pH)
o = 0
for i in range(0, 4):
o = o - cH[i] * numpy.exp(-(numpy.sum(aH[i, :] * ((L - pH[i, :]) ** 2))))
return o
def F20(L):
aH = [
[10, 3, 17, 3.5, 1.7, 8],
[0.05, 10, 17, 0.1, 8, 14],
[3, 3.5, 1.7, 10, 17, 8],
[17, 8, 0.05, 10, 0.1, 14],
]
aH = numpy.asarray(aH)
cH = [1, 1.2, 3, 3.2]
cH = numpy.asarray(cH)
pH = [
[0.1312, 0.1696, 0.5569, 0.0124, 0.8283, 0.5886],
[0.2329, 0.4135, 0.8307, 0.3736, 0.1004, 0.9991],
[0.2348, 0.1415, 0.3522, 0.2883, 0.3047, 0.6650],
[0.4047, 0.8828, 0.8732, 0.5743, 0.1091, 0.0381],
]
pH = numpy.asarray(pH)
o = 0
for i in range(0, 4):
o = o - cH[i] * numpy.exp(-(numpy.sum(aH[i, :] * ((L - pH[i, :]) ** 2))))
return o
def F21(L):
aSH = [
[4, 4, 4, 4],
[1, 1, 1, 1],
[8, 8, 8, 8],
[6, 6, 6, 6],
[3, 7, 3, 7],
[2, 9, 2, 9],
[5, 5, 3, 3],
[8, 1, 8, 1],
[6, 2, 6, 2],
[7, 3.6, 7, 3.6],
]
cSH = [0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5]
aSH = numpy.asarray(aSH)
cSH = numpy.asarray(cSH)
fit = 0
for i in range(5):
v = numpy.matrix(L - aSH[i, :])
fit = fit - ((v) * (v.T) + cSH[i]) ** (-1)
o = fit.item(0)
return o
def F22(L):
aSH = [
[4, 4, 4, 4],
[1, 1, 1, 1],
[8, 8, 8, 8],
[6, 6, 6, 6],
[3, 7, 3, 7],
[2, 9, 2, 9],
[5, 5, 3, 3],
[8, 1, 8, 1],
[6, 2, 6, 2],
[7, 3.6, 7, 3.6],
]
cSH = [0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5]
aSH = numpy.asarray(aSH)
cSH = numpy.asarray(cSH)
fit = 0
for i in range(7):
v = numpy.matrix(L - aSH[i, :])
fit = fit - ((v) * (v.T) + cSH[i]) ** (-1)
o = fit.item(0)
return o
def F23(L):
aSH = [
[4, 4, 4, 4],
[1, 1, 1, 1],
[8, 8, 8, 8],
[6, 6, 6, 6],
[3, 7, 3, 7],
[2, 9, 2, 9],
[5, 5, 3, 3],
[8, 1, 8, 1],
[6, 2, 6, 2],
[7, 3.6, 7, 3.6],
]
cSH = [0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5]
aSH = numpy.asarray(aSH)
cSH = numpy.asarray(cSH)
fit = 0
for i in range(10):
v = numpy.matrix(L - aSH[i, :])
fit = fit - ((v) * (v.T) + cSH[i]) ** (-1)
o = fit.item(0)
return o
def getFunctionDetails(a):
# [name, lb, ub, dim]
param = {
"F1": ["F1", -100, 100, 30],
"F2": ["F2", -10, 10, 30],
"F3": ["F3", -100, 100, 30],
"F4": ["F4", -100, 100, 30],
"F5": ["F5", -30, 30, 30],
"F6": ["F6", -100, 100, 30],
"F7": ["F7", -1.28, 1.28, 30],
"F8": ["F8", -500, 500, 30],
"F9": ["F9", -5.12, 5.12, 30],
"F10": ["F10", -32, 32, 30],
"F11": ["F11", -600, 600, 30],
"F12": ["F12", -50, 50, 30],
"F13": ["F13", -50, 50, 30],
"F14": ["F14", -65.536, 65.536, 2],
"F15": ["F15", -5, 5, 4],
"F16": ["F16", -5, 5, 2],
"F17": ["F17", -5, 15, 2],
"F18": ["F18", -2, 2, 2],
"F19": ["F19", 0, 1, 3],
"F20": ["F20", 0, 1, 6],
"F21": ["F21", 0, 10, 4],
"F22": ["F22", 0, 10, 4],
"F23": ["F23", 0, 10, 4],
}
return param.get(a, "nothing")
'''
# ESAs space mission design benchmarks https://www.esa.int/gsp/ACT/projects/gtop/
from fcmaes.astro import (
MessFull,
Messenger,
Gtoc1,
Cassini1,
Cassini2,
Rosetta,
Tandem,
Sagas,
)
def Ca1(x):
return Cassini1().fun(x)
def Ca2(x):
return Cassini2().fun(x)
def Ros(x):
return Rosetta().fun(x)
def Tan(x):
return Tandem(5).fun(x)
def Sag(x):
return Sagas().fun(x)
def Mef(x):
return MessFull().fun(x)
def Mes(x):
return Messenger().fun(x)
def Gt1(x):
return Gtoc1().fun(x)
def getFunctionDetails(a):
# [name, lb, ub, dim]
param = {
"F1": ["F1", -100, 100, 30],
"F2": ["F2", -10, 10, 30],
"F3": ["F3", -100, 100, 30],
"F4": ["F4", -100, 100, 30],
"F5": ["F5", -30, 30, 30],
"F6": ["F6", -100, 100, 30],
"F7": ["F7", -1.28, 1.28, 30],
"F8": ["F8", -500, 500, 30],
"F9": ["F9", -5.12, 5.12, 30],
"F10": ["F10", -32, 32, 30],
"F11": ["F11", -600, 600, 30],
"F12": ["F12", -50, 50, 30],
"F13": ["F13", -50, 50, 30],
"F14": ["F14", -65.536, 65.536, 2],
"F15": ["F15", -5, 5, 4],
"F16": ["F16", -5, 5, 2],
"F17": ["F17", -5, 15, 2],
"F18": ["F18", -2, 2, 2],
"F19": ["F19", 0, 1, 3],
"F20": ["F20", 0, 1, 6],
"F21": ["F21", 0, 10, 4],
"F22": ["F22", 0, 10, 4],
"F23": ["F23", 0, 10, 4],
"Ca1": [
"Ca1",
Cassini1().bounds.lb,
Cassini1().bounds.ub,
len(Cassini1().bounds.lb),
],
"Ca2": [
"Ca2",
Cassini2().bounds.lb,
Cassini2().bounds.ub,
len(Cassini2().bounds.lb),
],
"Gt1": ["Gt1", Gtoc1().bounds.lb, Gtoc1().bounds.ub, len(Gtoc1().bounds.lb)],
"Mes": [
"Mes",
Messenger().bounds.lb,
Messenger().bounds.ub,
len(Messenger().bounds.lb),
],
"Mef": [
"Mef",
MessFull().bounds.lb,
MessFull().bounds.ub,
len(MessFull().bounds.lb),
],
"Sag": ["Sag", Sagas().bounds.lb, Sagas().bounds.ub, len(Sagas().bounds.lb)],
"Tan": [
"Tan",
Tandem(5).bounds.lb,
Tandem(5).bounds.ub,
len(Tandem(5).bounds.lb),
],
"Ros": [
"Ros",
Rosetta().bounds.lb,
Rosetta().bounds.ub,
len(Rosetta().bounds.lb),
],
}
return param.get(a, "nothing")先写这么多，后续画图的函数下周二再更新，大家先学着吧。大家多多点赞哦
572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
