RCTF出了个OnePixelAttack的题，很早就看见过这个攻击了，于是尝试一下

One Pixel Attack With Differential Evolution

OnePixelAttack顾名思义，只修改一个像素来骗过Classfier，玩的非常极限，一开始我以为这样的攻击一定离不开梯度，但居然是用了差分演化这一优化算法，可以完全做到BlackBox攻击，只需要知道Classfier给出的Probability与Label即可

幸运的是，使用差分演化的OnePixelAttack在李宏毅的Channel上有过讲解，视频在此，看两遍差分演化的部分后就可以尝试自己搓一个来解题了

题目复述

本次RCTF给出的被攻击的model是ResNet50，分类结果的类别数量高达1000个，需要进行扰动的样本是一张60x60的猫咪图片，需要对其进行一个像素的扰动使其被分类为不是猫咪的类别，以下为原题前端代码：

from flask import Flask, render_template, request
from torchvision.models import resnet50, ResNet50_Weights
from PIL import Image
from flag import flag

def checkImg(Img):
    im = Image.open('static/start.png').convert('RGB')
    Img = Img.convert('RGB')
    if Img.size != (60, 60):
        return 0
    count = 0
    for i in range(60):
        for j in range(60):
            if im.getpixel((i,j)) != Img.getpixel((i,j)):
                count += 1
    if count == 1:
        return 1
    else:
        return 0

def divide(img):
  # Step 1: Initialize model with the best available weights
  weights = ResNet50_Weights.DEFAULT
  model = resnet50(weights=weights)
  model.eval()

  # Step 2: Initialize the inference transforms
  preprocess = weights.transforms()

  # Step 3: Apply inference preprocessing transforms
  batch = preprocess(img).unsqueeze(0)

  # Step 4: Use the model and print the predicted category
  prediction = model(batch).squeeze(0).softmax(0)
  class_id = prediction.argmax().item()
  score = prediction[class_id].item()
  category_name = weights.meta["categories"][class_id]
  return category_name,score


app = Flask(__name__)
@app.route('/', methods=['POST', 'GET'])
def welcome():
    return render_template("index.html")

@app.route('/upload', methods=['POST', 'GET'])
def upload():
    if request.method == 'POST':
        f = request.files['file']
        im = Image.open(f)
        if checkImg(im) == 0:
            return render_template('upload.html', error="image format error! the image size must be 60 x 60 and you can only change one pixel!")
        category_name,score = divide(im)
        if category_name == 'tabby' or "cat" in category_name:
            return render_template('upload.html', res=category_name + "  " + str(score))
        else:
            return render_template('upload.html', flag=flag)
    return render_template('upload.html',error='please start attack!')
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

需要进行扰动的样本：

差分演化

首先认识差分演化，简称DE

DE(func, cutoff, popSize, mut, CR, maxIter)

观察上述函数参数：

func：目标函数
cutoff：阈值
popSize：族群大小
mut：进化参数
CR：杂交参数
maxIter：最大迭代次数

我们期望上述函数在maxIter内找到一个向量X，使func(X)的值大于或小于（这取决于结果的需求）cutoff

具体流程

在此简述DE的流程，以免遗忘

现有一名为func的黑盒/白盒函数，其接受向量X作为参数

现使用DE()求使得func()尽可能小的向量

随机初始化popSize个向量作为族群pop，这些向量符合func对输入向量的要求
当族群pop中不存在任何一个向量x满足func(x)<cutoff：
- 使族群pop中的每一个向量x作为杂交父向量之一：
  - 随机选取3个pop中的向量a,b,c，且他们与x不相等
  - 令另一杂交父向量mutant=a+mut*(b-c)
  - 随机生成长度与x相同的仅包含True,False的向量，每个元素为True的可能性为CR，称此01向量为crossOver
  - 使mutant与x进行杂交，生成的杂交子向量为child=x*(1-crossOver)+mutant*crossOver
  - 如果child中的元素越界，有几种处理办法：
    - Clip（较为保守的办法，会一定程度降低多样性）
    - 取余（较为中庸的办法）
    - 取随机数（较为激进的办法，增加多样性但可能导致混乱程度增加，更难收敛）
  - 当func(child)<func(x)
    - 更新族群x=child
返回满足func(x)<cutoff的向量x

调参

可以先参考这篇挂豆丁的中文论文，里面介绍了各个参数的效果以及如何改进，但我觉得implement起来性价比最高的就是动态调整的F和随机生成的CR

在此总结一下：

F∈[0,2]，最好设置成动态的
CR∈(0,1)
popSize：通常在50以内，但理论上越大则越有可能找到全局最优解，但太大了会导致收益不足以弥补计算速度过慢带来的损失
maxIter：如果采用动态F，则需要斟酌一下，例如我的F就与maxIter有关F=alpha*(np.exp(maxIter/(maxIter+iterCnt))-1)

Copilot带来的问题

在最开始用魔改版Copilot生成的DE解决这个题目时，经常遇到的一个问题：在某一时刻（通常是演化的初期），突然整个族群都进行了一次演化，即在一次进化中，整个族群都更新了，但在这之后，就不再有任何一个向量在演化中改变

后记：对于上述现象，其实就是Copilot写的比较拉，在多次魔改后此bug凭空消失。感觉是因为Copilot写的代码中，对于待优化的函数定义模糊，变量关系混乱，参考的变量过于单一。详细地说，就是ResNet中的类别数量高达1000个，其Label中带有"cat"的就有十来个（不同品种的猫），也许在某一时刻，一个噪音成功更改了Label，但只是把Label从最初的Persian Cat改成了另一种Cat，这个成功的噪音顺利成为了最佳噪音；因为需要计算最佳噪音的fitness和预测结果，导致原本是Persian Cat的classID被改成另一种猫的classID；这一更改使得族群的fitness值整体大幅下降，整个族群或者绝大多数向量都接受了新的child，导致我们看到的突然大规模更新的现象，而因为另一种猫的概率本身就不高，梯度过于平缓甚至消失，DE在一片大平地上难以发挥作用，导致我们看到的在大规模更新后再无更新的现象

（找这个bug真的给我找麻了，虽然不是有意修复了bug，但我觉得bug成因应该是这样的

虽然这个bug是Copilot造成的，但我之前也google了相关问题，找到了On_Stagnation_Of_The_Differential_Evolution_Algorithm，解释了一下为什么DE算法中存在族群停止演化的现象

感觉他说了挺多的，又感觉他什么也没说，总之在没有我这个bug的情况下，就是扩大种群规模，提供更广泛的多样性，就能使得停滞的概率减小，而停滞的成因则是陷入局部最优解（乐

我还去问了ChatGPT，都是AI应该比较互相了解（乐：

虽然点了很多次Try Again也没找出族群突然全体突变的bug，但倒是给我把另一个Copilot写的bug给我找出来了，就是target vector居然是随机取的而不是挨个儿来，毕竟这一堆东西里面random用的挺多的，我还真没看出来，于是立刻改掉然后做成标准的DE了

输出

说实话，特别是这种看运气的程序，盯着输出终端等success就很紧张，所以记录几段输出，见证一下

alpha=0.4，popSize=20，maxIter=100

('Persian cat', 0.265370637178421)

 ### Starting DE Attack 1 ###

Initializing Differential Evolution
Initializing fitness:  20

 # iter:  1 best fitness:  0.2845600592554547 best solution:  [ 29   4 202 195  42]
    - F:  0.6766003777597516
    - vec:  20
    - changed vec num:  11
    🔵 new best fitness:  0.26558117862441577  new best solution:  [ 10  37   4 244  71]
    🔵 prediction:  ('Persian cat', 0.16487646102905273)
    - mean fitness:  0.31238916044676446
 # iter:  2 best fitness:  0.26558117862441577 best solution:  [ 10  37   4 244  71]
    - F:  0.6662005326545324
    - vec:  20
    - changed vec num:  6
    - mean fitness:  0.3056630621358636
 # iter:  3 best fitness:  0.26558117862441577 best solution:  [ 10  37   4 244  71]
    - F:  0.656100186679759
    - vec:  20
    - changed vec num:  6
    🔵 new best fitness:  0.24916027527069673  new best solution:  [ 24  31 134 197  94]
    🔵 prediction:  ('Persian cat', 0.16068297624588013)
    - mean fitness:  0.2983871838674531
 # iter:  4 best fitness:  0.24916027527069673 best solution:  [ 24  31 134 197  94]
    - F:  0.6462870241393159
    - vec:  20
    - changed vec num:  4
    - mean fitness:  0.2935906742452062
 # iter:  5 best fitness:  0.24916027527069673 best solution:  [ 24  31 134 197  94]
    - F:  0.6367493783259498
    - vec:  20
    - changed vec num:  4
    - mean fitness:  0.28915020487766013
 # iter:  6 best fitness:  0.24916027527069673 best solution:  [ 24  31 134 197  94]
    - F:  0.6274761901752574
    - vec:  20
    - changed vec num:  5
    - mean fitness:  0.2849028466225718
 # iter:  7 best fitness:  0.24916027527069673 best solution:  [ 24  31 134 197  94]
    - F:  0.6184569699902873
    - vec:  20
    - changed vec num:  2
    - mean fitness:  0.27997543959209
 # iter:  8 best fitness:  0.24916027527069673 best solution:  [ 24  31 134 197  94]
    - F:  0.6096817619774788
    - vec:  20
    - changed vec num:  6
    🔵 new best fitness:  0.2081426924560219  new best solution:  [ 26  28 207 212 232]
    🔵 prediction:  ('Persian cat', 0.13251474499702454)
    - mean fitness:  0.27476091143325904
 # iter:  9 best fitness:  0.2081426924560219 best solution:  [ 26  28 207 212 232]
    - F:  0.6011411113590921
    - vec:  20
    - changed vec num:  5
    - mean fitness:  0.27236858464457325
 # iter:  10 best fitness:  0.2081426924560219 best solution:  [ 26  28 207 212 232]
    - F:  0.5928260338492048
    - vec:  20
    - changed vec num:  5
    🔵 new best fitness:  0.19687939991126768  new best solution:  [ 26  28 246 212 232]
    🔵 prediction:  ('Persian cat', 0.12056729197502136)
    - mean fitness:  0.2706069266641862
 # iter:  11 best fitness:  0.19687939991126768 best solution:  [ 26  28 246 212 232]
    - F:  0.5847279872999954
    - vec:  20
    - changed vec num:  2
    🔵 new best fitness:  0.167548724275548  new best solution:  [  9  32  14 119 170]
    🔵 prediction:  ('Siamese cat', 0.06791895627975464)
    - mean fitness:  0.2661146746744635
 # iter:  12 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5768388453426972
    - vec:  20
    - changed vec num:  4
    - mean fitness:  0.2630609781524981
 # iter:  13 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5691508728634869
    - vec:  20
    - changed vec num:  5
    - mean fitness:  0.2571228217886528
 # iter:  14 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.561656703168862
    - vec:  20
    - changed vec num:  4
    - mean fitness:  0.25257750129821943
 # iter:  15 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5543493167079622
    - vec:  20
    - changed vec num:  2
    - mean fitness:  0.25171417870151347
 # iter:  16 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5472220212308999
    - vec:  20
    - changed vec num:  3
    - mean fitness:  0.25043370262428655
 # iter:  17 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5402684332726887
    - vec:  20
    - changed vec num:  1
    - mean fitness:  0.24717705660732464
 # iter:  18 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.533482460861836
    - vec:  20
    - changed vec num:  0
    - mean fitness:  0.24717705660732464
 # iter:  19 best fitness:  0.167548724275548 best solution:  [  9  32  14 119 170]
    - F:  0.5268582873612809
    - vec:  20
    - changed vec num:  2
    🔵 new best fitness:  0.12234273354988545  new best solution:  [  9  32  14  50 170]
    🔵 prediction:  ('goldfish', 0.06539428979158401)
    - mean fitness:  0.24463605969795027

🟢 Holy shit, solution found! Now it's a  goldfish with probability 0.06539428979158401

alpha=0.4，popSize=50，maxIter=100

('Persian cat', 0.265370637178421)

 ### Starting DE Attack 1 ###

Initializing Differential Evolution
Initializing fitness:  40

 # iter:  1 best fitness:  0.2792421304038726 best solution:  [ 39  15  57 207  64]
    - F:  0.6766003777597516
    - vec:  40
    - changed vec num:  15
    🔵 new best fitness:  0.24962108858744614  new best solution:  [ 13  37  12  55 187]
    🔵 prediction:  ('Siamese cat', 0.1373663693666458)
    - mean fitness:  0.3119236789265415
 # iter:  2 best fitness:  0.24962108858744614 best solution:  [ 13  37  12  55 187]
    - F:  0.6662005326545324
    - vec:  40
    - changed vec num:  14
    - mean fitness:  0.30659447693833497
 # iter:  3 best fitness:  0.24962108858744614 best solution:  [ 13  37  12  55 187]
    - F:  0.656100186679759
    - vec:  40
    - changed vec num:  18
    🔵 new best fitness:  0.2070837609935552  new best solution:  [  8  30  91  66 239]
    🔵 prediction:  ('Persian cat', 0.09145677834749222)
    - mean fitness:  0.2969437881693011
 # iter:  4 best fitness:  0.2070837609935552 best solution:  [  8  30  91  66 239]
    - F:  0.6462870241393159
    - vec:  40
    - changed vec num:  12
    - mean fitness:  0.29271303782225006
 # iter:  5 best fitness:  0.2070837609935552 best solution:  [  8  30  91  66 239]
    - F:  0.6367493783259498
    - vec:  40
    - changed vec num:  10
    - mean fitness:  0.2910425961643341
 # iter:  6 best fitness:  0.2070837609935552 best solution:  [  8  30  91  66 239]
    - F:  0.6274761901752574
    - vec:  40
    - changed vec num:  7
    - mean fitness:  0.2881202471602592
 # iter:  7 best fitness:  0.2070837609935552 best solution:  [  8  30  91  66 239]
    - F:  0.6184569699902873
    - vec:  40
    - changed vec num:  8
    🔵 new best fitness:  0.1985895600519143  new best solution:  [  8  30  83  43 246]
    🔵 prediction:  ('Persian cat', 0.0852014571428299)
    - mean fitness:  0.2845774589579378
 # iter:  8 best fitness:  0.1985895600519143 best solution:  [  8  30  83  43 246]
    - F:  0.6096817619774788
    - vec:  40
    - changed vec num:  10
    🔵 new best fitness:  0.1980369116354268  new best solution:  [ 19  31 221  60 219]
    🔵 prediction:  ('Persian cat', 0.12450581043958664)
    - mean fitness:  0.2800736110439175
 # iter:  9 best fitness:  0.1980369116354268 best solution:  [ 19  31 221  60 219]
    - F:  0.6011411113590921
    - vec:  40
    - changed vec num:  9
    - mean fitness:  0.2778595529278391
 # iter:  10 best fitness:  0.1980369116354268 best solution:  [ 19  31 221  60 219]
    - F:  0.5928260338492048
    - vec:  40
    - changed vec num:  6
    - mean fitness:  0.27586468316367246
 # iter:  11 best fitness:  0.1980369116354268 best solution:  [ 19  31 221  60 219]
    - F:  0.5847279872999954
    - vec:  40
    - changed vec num:  7
    - mean fitness:  0.2737868920994515
 # iter:  12 best fitness:  0.1980369116354268 best solution:  [ 19  31 221  60 219]
    - F:  0.5768388453426972
    - vec:  40
    - changed vec num:  10
    - mean fitness:  0.27152785387224865
 # iter:  13 best fitness:  0.1980369116354268 best solution:  [ 19  31 221  60 219]
    - F:  0.5691508728634869
    - vec:  40
    - changed vec num:  5
    🔵 new best fitness:  0.19654489058302715  new best solution:  [  8  30  83  43 232]
    🔵 prediction:  ('Persian cat', 0.08681343495845795)
    - mean fitness:  0.26959856572939317
 # iter:  14 best fitness:  0.19654489058302715 best solution:  [  8  30  83  43 232]
    - F:  0.561656703168862
    - vec:  40
    - changed vec num:  8
    - mean fitness:  0.26641814589238494
 # iter:  15 best fitness:  0.19654489058302715 best solution:  [  8  30  83  43 232]
    - F:  0.5543493167079622
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.2645324606302893
 # iter:  16 best fitness:  0.19654489058302715 best solution:  [  8  30  83  43 232]
    - F:  0.5472220212308999
    - vec:  40
    - changed vec num:  9
    🔵 new best fitness:  0.18593154309201054  new best solution:  [ 13  32  12  10 187]
    🔵 prediction:  ('Persian cat', 0.08130055665969849)
    - mean fitness:  0.25822097945274436
 # iter:  17 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.5402684332726887
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.25611360947732464
 # iter:  18 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.533482460861836
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.2554245814695605
 # iter:  19 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.5268582873612809
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.25354099731121094
 # iter:  20 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.52039035635713
    - vec:  40
    - changed vec num:  6
    - mean fitness:  0.25284817432111595
 # iter:  21 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.5140733575177235
    - vec:  40
    - changed vec num:  7
    - mean fitness:  0.24981836683436995
 # iter:  22 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.507902213351963
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.2459833693370456
 # iter:  23 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.5018720668016673
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.24333137386493037
 # iter:  24 best fitness:  0.18593154309201054 best solution:  [ 13  32  12  10 187]
    - F:  0.49597826960801883
    - vec:  40
    - changed vec num:  6
    🔵 new best fitness:  0.17529693761025555  new best solution:  [ 19  33 107 202  87]
    🔵 prediction:  ('Persian cat', 0.11591507494449615)
    - mean fitness:  0.23850348221239984
 # iter:  25 best fitness:  0.17529693761025555 best solution:  [ 19  33 107 202  87]
    - F:  0.49021637139698715
    - vec:  40
    - changed vec num:  4
    🔵 new best fitness:  0.16616633877856657  new best solution:  [ 8 30 91 31 67]
    🔵 prediction:  ('Persian cat', 0.09061149507761002)
    - mean fitness:  0.23500263207024547
 # iter:  26 best fitness:  0.16616633877856657 best solution:  [ 8 30 91 31 67]
    - F:  0.48458210943301233
    - vec:  40
    - changed vec num:  1
    🔵 new best fitness:  0.1616513744520489  new best solution:  [ 19  28   5 102  29]
    🔵 prediction:  ('Persian cat', 0.10139482468366623)
    - mean fitness:  0.23261223865411013
 # iter:  27 best fitness:  0.1616513744520489 best solution:  [ 19  28   5 102  29]
    - F:  0.479071398994239
    - vec:  40
    - changed vec num:  5
    🔵 new best fitness:  0.14602759646368213  new best solution:  [ 16  34   1   3 205]
    🔵 prediction:  ('Persian cat', 0.07026080787181854)
    - mean fitness:  0.22903343415091512
 # iter:  28 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.4736803243262472
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.22653961733085454
 # iter:  29 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.46840513013457596
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.22535609000551632
 # iter:  30 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.46324221357937834
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.2251134257450758
 # iter:  31 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.45818811673835536
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.22436150974099292
 # iter:  32 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.4532395195066663
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.2225118848582497
 # iter:  33 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.4483932329048621
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.2216588508694258
 # iter:  34 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.44364619276804285
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.22057820814152365
 # iter:  35 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.43899545379140953
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.21989876355437446
 # iter:  36 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.4344381839091998
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.2197925534543174
 # iter:  37 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.4299716589856594
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.218737456479721
 # iter:  38 best fitness:  0.14602759646368213 best solution:  [ 16  34   1   3 205]
    - F:  0.42559325779824
    - vec:  40
    - changed vec num:  1
    🔵 new best fitness:  0.14172421832336113  new best solution:  [ 19  33  30 202  87]
    🔵 prediction:  ('Persian cat', 0.08732357621192932)
    - mean fitness:  0.21789813849754863
 # iter:  39 best fitness:  0.14172421832336113 best solution:  [ 19  33  30 202  87]
    - F:  0.4213004572946206
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.21529108281320078
 # iter:  40 best fitness:  0.14172421832336113 best solution:  [ 19  33  30 202  87]
    - F:  0.4170908281064568
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.21383756285431446
 # iter:  41 best fitness:  0.14172421832336113 best solution:  [ 19  33  30 202  87]
    - F:  0.4129620303039511
    - vec:  40
    - changed vec num:  6
    🔵 new best fitness:  0.13738378579728305  new best solution:  [ 9 34  0 26 64]
    🔵 prediction:  ('Persian cat', 0.07210958003997803)
    - mean fitness:  0.20868932269731885
 # iter:  42 best fitness:  0.13738378579728305 best solution:  [ 9 34  0 26 64]
    - F:  0.40891180937645544
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.2078212516120402
 # iter:  43 best fitness:  0.13738378579728305 best solution:  [ 9 34  0 26 64]
    - F:  0.4049379924253286
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.20408854874112875
 # iter:  44 best fitness:  0.13738378579728305 best solution:  [ 9 34  0 26 64]
    - F:  0.40103848455621577
    - vec:  40
    - changed vec num:  0
    - mean fitness:  0.20408854874112875
 # iter:  45 best fitness:  0.13738378579728305 best solution:  [ 9 34  0 26 64]
    - F:  0.39721126545879254
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.20378129609016468
 # iter:  46 best fitness:  0.13738378579728305 best solution:  [ 9 34  0 26 64]
    - F:  0.39345438616281747
    - vec:  40
    - changed vec num:  3
    🔵 new best fitness:  0.1299925823986996  new best solution:  [ 19  28   5 102  82]
    🔵 prediction:  ('Persian cat', 0.07040903717279434)
    - mean fitness:  0.20264634452323663
 # iter:  47 best fitness:  0.1299925823986996 best solution:  [ 19  28   5 102  82]
    - F:  0.3897659659600848
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.20154688280672417
 # iter:  48 best fitness:  0.1299925823986996 best solution:  [ 19  28   5 102  82]
    - F:  0.3861441894825582
    - vec:  40
    - changed vec num:  5
    🔵 new best fitness:  0.1224242995667737  new best solution:  [ 19  28  42  26 126]
    🔵 prediction:  ('Persian cat', 0.055999837815761566)
    - mean fitness:  0.19660467324938508
 # iter:  49 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.38258730392760887
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.1962674061607686
 # iter:  50 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.37909361642187034
    - vec:  40
    - changed vec num:  4
    - mean fitness:  0.1943786095136602
 # iter:  51 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3756614915157772
    - vec:  40
    - changed vec num:  6
    - mean fitness:  0.19027078175422502
 # iter:  52 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.37228934880136033
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.18975930064043495
 # iter:  53 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3689756606463516
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.18946195252865436
 # iter:  54 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3657189500380862
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.18909707230777711
 # iter:  55 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.36251778853110245
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.1873159199443762
 # iter:  56 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.359370794292723
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.18381733766582328
 # iter:  57 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.35627663024124995
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.1830537809233647
 # iter:  58 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3532340022717441
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.18271953661824228
 # iter:  59 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3502416575646581
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.18242792503733654
 # iter:  60 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.34729838297288895
    - vec:  40
    - changed vec num:  6
    - mean fitness:  0.18039965996067622
 # iter:  61 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3444030034830755
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.18006657009755145
 # iter:  62 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.34155438074722033
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.179565512255067
 # iter:  63 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3387514116809485
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.17945913075454883
 # iter:  64 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3359930271249306
    - vec:  40
    - changed vec num:  3
    - mean fitness:  0.17832086661219365
 # iter:  65 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3332781905662051
    - vec:  40
    - changed vec num:  0
    - mean fitness:  0.17832086661219365
 # iter:  66 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3306058969163208
    - vec:  40
    - changed vec num:  2
    - mean fitness:  0.1771787651014165
 # iter:  67 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3279751713434023
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.17541003143414854
 # iter:  68 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.3253850681554063
    - vec:  40
    - changed vec num:  5
    - mean fitness:  0.17219932818989037
 # iter:  69 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.32283466973198904
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.17194998578561355
 # iter:  70 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.32032308550255917
    - vec:  40
    - changed vec num:  1
    - mean fitness:  0.1713867742641014
 # iter:  71 best fitness:  0.1224242995667737 best solution:  [ 19  28  42  26 126]
    - F:  0.31784945096821904
    - vec:  40
    - changed vec num:  3
    🔵 new best fitness:  0.1114595357212238  new best solution:  [  9  30  15  26 105]
    🔵 prediction:  ('goldfish', 0.07046791166067123)
    - mean fitness:  0.1694240938144503

🟢 Holy shit, solution found! Now it's a  goldfish with probability 0.07046791166067123

alpha=0.4，popSize=200，maxIter=100

('Persian cat', 0.265370637178421)

 ### Starting DE Attack 1 ###      

Initializing Differential Evolution
Initializing fitness:  200

 # iter:  1 best fitness:  0.24225685829878785 best solution:  [ 12  39  95 221 124]
    - F:  0.6766003777597516
    - vec:  200
    - changed vec num:  106
    🔵 new best fitness:  0.14112568460404873  new best solution:  [ 22  32 143 101   2]
    🔵 prediction:  ('Persian cat', 0.08040182292461395)
    - mean fitness:  0.3115253244334599
 # iter:  2 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6662005326545324
    - vec:  200
    - changed vec num:  70
    - mean fitness:  0.3050887870359293
 # iter:  3 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.656100186679759
    - vec:  200
    - changed vec num:  63
    - mean fitness:  0.30018534842150985
 # iter:  4 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6462870241393159
    - vec:  200
    - changed vec num:  61
    - mean fitness:  0.2930651634036622
 # iter:  5 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6367493783259498
    - vec:  200
    - changed vec num:  48
    - mean fitness:  0.2894190900228568
 # iter:  6 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6274761901752574
    - vec:  200
    - changed vec num:  45
    - mean fitness:  0.2862749499891652
 # iter:  7 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6184569699902873
    - vec:  200
    - changed vec num:  34
    - mean fitness:  0.283543661233125
 # iter:  8 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6096817619774788
    - vec:  200
    - changed vec num:  34
    - mean fitness:  0.28058190911469866
 # iter:  9 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.6011411113590921
    - vec:  200
    - changed vec num:  34
    - mean fitness:  0.27765514108512435
 # iter:  10 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.5928260338492048
    - vec:  200
    - changed vec num:  27
    - mean fitness:  0.275277993111813
 # iter:  11 best fitness:  0.14112568460404873 best solution:  [ 22  32 143 101   2]
    - F:  0.5847279872999954
    - vec:  200
    - changed vec num:  25
    🔵 new best fitness:  0.12863419004133902  new best solution:  [  8  31  29  26 118]
    🔵 prediction:  ('goldfish', 0.0704464316368103)
    - mean fitness:  0.27182799993403023

🟢 Holy shit, solution found! Now it's a  goldfish with probability 0.0704464316368103

通过以上各个参数的迭代次数可见，族群大小对这个算法的收效甚微，只要不是太小的族群，在算法正确的情况下一般是没有问题的，比如上述的不同族群大小中，popSize=20时两三秒就可以进行一次迭代，而popSize=200时一次迭代就要几分钟，故而盲目追求大族群是得不偿失的，不如用小族群多跑几遍

然后是这个输出的结果，每次基本都是在猫耳朵的位置修改像素，得到goldfish的label，意味着Persian Cat的决策范围边上就是Goldfish，而且距离之近或者说梯度之大只需要一个像素就可以扰动成功

性能比较

copy了一份论文link的github上的代码，进行了一下性能的对比，这种带运气成分的算法需要大量统计才能做出比较，直观感觉上来说，相同种群大小下，他的一次迭代比我的慢得多，他的代码和我的一样有运气好几次迭代直接出和运气差迭代半天一直不出的情况，但是从原理上说，只要一直挂着跑，失败了自动重启继续跑，都肯定可以跑出来的

popSize=15，maxIter=100

0.33761785909882747

differential_evolution step 1: f(x)= 0.177579
Current solution:  [  7.89136557  29.78098292   0.66838417  26.92418736 187.89591321] Current Prediction:  ('Persian cat', 0.09029071778059006)

differential_evolution step 2: f(x)= 0.177579
Current solution:  [  7.89136557  29.78098292   0.66838417  26.92418736 187.89591321] Current Prediction:  ('Persian cat', 0.09029071778059006)

differential_evolution step 3: f(x)= 0.177579
Current solution:  [  7.89136557  29.78098292   0.66838417  26.92418736 187.89591321] Current Prediction:  ('Persian cat', 0.09029071778059006)

differential_evolution step 4: f(x)= 0.177579
Current solution:  [  7.89136557  29.78098292   0.66838417  26.92418736 187.89591321] Current Prediction:  ('Persian cat', 0.09029071778059006)

differential_evolution step 5: f(x)= 0.164309
Current solution:  [  8.16682606  31.87408249  35.702065    66.00663295 147.64079443] Current Prediction:  ('Persian cat', 0.07545000314712524)

differential_evolution step 6: f(x)= 0.156934
Current solution:  [  7.63761519  32.62248531  17.25317435   1.4109334  124.63028139] Current Prediction:  ('Persian cat', 0.07208419591188431)

differential_evolution step 7: f(x)= 0.156934
Current solution:  [  7.63761519  32.62248531  17.25317435   1.4109334  124.63028139] Current Prediction:  ('Persian cat', 0.07208419591188431) 

differential_evolution step 8: f(x)= 0.125927
Solution found:  [ 8.58543511 29.28549154 35.04627611 30.05577958 80.01537897] 

     fun: 0.12592693569604307
 message: 'callback function requested stop early by returning True'
    nfev: 681
     nit: 8
 success: False
       x: array([ 8.58543511, 29.28549154, 35.04627611, 30.05577958, 80.01537897])

('goldfish', 0.07302950322628021)

exp

poc.py

from torchvision.models import resnet50, ResNet50_Weights
from PIL import Image
import numpy as np
# from DE import differential_evolution


'''Differential Evolution Test'''
# def fooCallBack(x, convergence):
#     if foo(x) < 5:
#         print("Solution found: ", x, "\n")
#         return True
#     else:
#         print("Current solution: ", x, "Current fitness: ", foo(x), "\n")
#         return False


# def foo(x):
#     if x.ndim == 1:
#         x = np.array([x])
#     return np.sum(np.square(x), axis=1)


# solution = differential_evolution(
#     foo, bounds=[(-255, 255), (-255, 255), (-255, 255)], disp=True, callback=fooCallBack)
# print(solution)


'''One Pixel Attack'''
weights = ResNet50_Weights.DEFAULT
model = resnet50(weights=weights)
model.eval()
preprocess = weights.transforms()


startPath = 'E:/DL/_media_file_task_0dddc5b6-cb34-4468-b20c-abb5d7d0befa/RCTF_catspy/static/start.png'
outPath = 'E:/DL/_media_file_task_0dddc5b6-cb34-4468-b20c-abb5d7d0befa/RCTF_catspy/out.png'
startImg = Image.open(startPath).convert('RGB')


def ChangeOnePixel(img, pert):
    img = np.array(img)
    img[int(pert[0])][int(pert[1])] = pert[2:]
    return img


def GetScore(img):
    if isinstance(img, np.ndarray):
        img = Image.fromarray(img.astype('uint8')).convert('RGB')
    batch = preprocess(img).unsqueeze(0)
    prediction = model(batch).squeeze(0).softmax(0)
    score = 0
    for i in [143, 282, 283, 284, 285, 358, 383, 484]:
        score += prediction[i].item()
    return score


def Predict(img):
    if isinstance(img, np.ndarray):
        img = Image.fromarray(img.astype('uint8')).convert('RGB')
    batch = preprocess(img).unsqueeze(0)
    prediction = model(batch).squeeze(0).softmax(0)
    class_id = prediction.argmax().item()
    score = prediction[class_id].item()
    category_name = weights.meta["categories"][class_id]
    return category_name, score


def GetPertedScore(perts):
    if perts.ndim == 1:
        perts = np.array([perts])
    res = []
    for pert in perts:
        img = ChangeOnePixel(startImg, pert)
        img = Image.fromarray(img.astype('uint8')).convert('RGB')
        res.append(GetScore(img))
    return np.array(res)


def OPACallBack(x, convergence):
    prediction = Predict(ChangeOnePixel(startImg, x))
    if "cat" not in prediction[0]:
        print("Solution found: ", x, "\n")
        return True
    else:
        print("Current solution: ", x, "Current Prediction: ", prediction, "\n")
        return False
    

'''
Solution for Catspy Using Differential Evolution From
https://github.com/Hyperparticle/one-pixel-attack-keras/tree/8261f976be922bd9b470040367a34d82fcd506d4
'''
# print(GetScore(startImg), "\n")
# solution = differential_evolution(GetPertedScore, bounds=[(0,59), (0,59), (0,255), (0,255), (0,255)], maxiter=100, popsize=15, disp=True, callback=OPACallBack)
# print(solution)
# print(Predict(ChangeOnePixel(startImg, solution.x)))


'''Hand Made Differential Evolution Attack'''
def OPA(img, pop_size, maxIter, alpha=0.4):
    '''
    img: the image to be attacked
    pop_size: the size of the population
    maxIter: the maximum number of iterations
    alpha: the mutation factor, [0.2, 0.6]
    '''
    global attackCnt
    attackCnt = 0

    def init():
        global attackCnt
        attackCnt += 1
        print("\n ### Starting DE Attack", attackCnt, "###\n")
        # Step 5.1: Initialize the population
        print("Initializing Differential Evolution")
        pop = np.concatenate((np.random.randint(0, 60, (pop_size, 2)), np.random.randint(0, 256, (pop_size, 3))), axis=1)
        pop = np.array(pop, dtype=np.uint8)
        # Step 5.2: Initialize the fitness
        fitness = np.zeros(pop_size)
        for i in range(pop_size):
            if i % 10 == 9:
                print("\rInitializing fitness: ", i+1, end="")
            fitness[i] = GetScore(ChangeOnePixel(img, pop[i]))
        print("\n")
        # Step 5.3: Initialize the best fitness
        best_fitness = np.min(fitness)
        # Step 5.4: Initialize the best solution
        best_solution = pop[fitness.argmin()]
        best_prediction = Predict(ChangeOnePixel(img, best_solution))
        # Step 5.5: Initialize the iteration
        iterCnt = 0
        noVecChangedCnt = 0
        return pop, fitness, best_fitness, best_solution, iterCnt, noVecChangedCnt, best_prediction, [], []

    print(Predict(img))

    # Step 5: Differential Evolution Attack
    pop, fitness, best_fitness, best_solution, iterCnt, noVecChangedCnt, best_prediction, popHistory, fitnessHistory = init()
    
    while True:
        
        if noVecChangedCnt == 5 or iterCnt == maxIter:
            pop, fitness, best_fitness, best_solution, iterCnt, noVecChangedCnt, best_prediction, popHistory, fitnessHistory = init()

        iterCnt += 1
        lastPop = np.array(pop)
        popHistory.append(np.array(pop))
        fitnessHistory.append(np.array(fitness))
        changedVec = 0
        print(" # iter: ", iterCnt, "best fitness: ", best_fitness, "best solution: ", best_solution)
        F = alpha * (np.exp(maxIter / (maxIter + iterCnt)) - 1)
        print("    - F: ", F)
        for i in range(pop_size):
            if i % 10 == 9:
                print("\r    - vec: ", i+1, end="")
            # Step 5.5.2: Initialize the mutation vector
            mutation = np.random.randint(0, pop_size, 3)
            while i in mutation:
                mutation = np.random.randint(0, pop_size, 3)
            # Step 5.5.3: Initialize the crossover vector
            CR = 0.25 + np.random.rand() * 0.5
            crossover = np.random.rand(5) < CR
            # Step 5.5.4: Initialize the trial vector
            trial = np.array(lastPop[i] * (1 - crossover) + (lastPop[mutation[0]] + F * (lastPop[mutation[1]] - lastPop[mutation[2]])) * crossover, dtype=np.uint8)
            for trialIndex in range(2):
                if not 0 <= trial[trialIndex] <= 59:
                    trial[trialIndex] = np.random.randint(0, 60)
            for trialIndex in range(2, 5):
                if not 0 <= trial[trialIndex] <= 255:
                    trial[trialIndex] = np.random.randint(0, 256)
            # Step 5.5.5: Update the population
            newFitness = GetScore(ChangeOnePixel(img, trial))
            if newFitness < fitness[i]:
                pop[i] = np.array(trial, dtype=np.uint8)
                fitness[i] = newFitness
                changedVec += 1
            if changedVec > pop_size * 2 / 3:
                pass
        print()
        
        print('    - changed vec num: ', changedVec)
        noVecChangedCnt += 1 if changedVec == 0 else 0
        if changedVec != 0:
            noVecChangedCnt = 0
            
        # Step 5.7: Update the best fitness
        if np.min(fitness) < best_fitness:
            best_fitness = np.min(fitness)
            best_solution = pop[fitness.argmin()]
            print('    🔵 new best fitness: ', best_fitness, ' new best solution: ', best_solution)
            best_prediction = Predict(ChangeOnePixel(img, best_solution))
            print('    🔵 prediction: ', Predict(ChangeOnePixel(img, best_solution)))
        print('    - mean fitness: ', np.mean(fitness))
        
        if "cat" not in best_prediction[0]:
            print("\n🟢 Holy shit, solution found! Now it's a", best_prediction[0], "with probability", best_prediction[1])
            break
        
    return best_solution, popHistory, fitnessHistory

best_solution, popHistory, fitnessHistory = OPA(startImg, 20, 200, alpha=0.5)

DE.py

from scipy._lib._util import check_random_state
from scipy.optimize._optimize import _status_message
from scipy.optimize import OptimizeResult, minimize
import numpy as np


"""
A slight modification to Scipy's implementation of differential evolution. To speed up predictions, the entire parameters array is passed to `self.func`, where a neural network model can batch its computations and execute in parallel. Search for `CHANGES` to find all code changes.

Dan Kondratyuk 2018

Original code adapted from
https://github.com/scipy/scipy/blob/70e61dee181de23fdd8d893eaa9491100e2218d7/scipy/optimize/_differentialevolution.py
----------

differential_evolution: The differential evolution global optimization algorithm
Added by Andrew Nelson 2014
"""


_MACHEPS = np.finfo(np.float64).eps


def differential_evolution(func, bounds, args=(), strategy='best1bin',
                           maxiter=1000, popsize=15, tol=0.01,
                           mutation=(0.5, 1), recombination=0.7, seed=None,
                           callback=None, disp=False, polish=True,
                           init='latinhypercube', atol=0):
    """Finds the global minimum of a multivariate function.
    Differential Evolution is stochastic in nature (does not use gradient
    methods) to find the minimium, and can search large areas of candidate
    space, but often requires larger numbers of function evaluations than
    conventional gradient based techniques.
    The algorithm is due to Storn and Price [1]_.
    Parameters
    ----------
    func : callable
        The objective function to be minimized.  Must be in the form
        ``f(x, *args)``, where ``x`` is the argument in the form of a 1-D array
        and ``args`` is a  tuple of any additional fixed parameters needed to
        completely specify the function.
    bounds : sequence
        Bounds for variables.  ``(min, max)`` pairs for each element in ``x``,
        defining the lower and upper bounds for the optimizing argument of
        `func`. It is required to have ``len(bounds) == len(x)``.
        ``len(bounds)`` is used to determine the number of parameters in ``x``.
    args : tuple, optional
        Any additional fixed parameters needed to
        completely specify the objective function.
    strategy : str, optional
        The differential evolution strategy to use. Should be one of:
            - 'best1bin'
            - 'best1exp'
            - 'rand1exp'
            - 'randtobest1exp'
            - 'currenttobest1exp'
            - 'best2exp'
            - 'rand2exp'
            - 'randtobest1bin'
            - 'currenttobest1bin'
            - 'best2bin'
            - 'rand2bin'
            - 'rand1bin'
        The default is 'best1bin'.
    maxiter : int, optional
        The maximum number of generations over which the entire population is
        evolved. The maximum number of function evaluations (with no polishing)
        is: ``(maxiter + 1) * popsize * len(x)``
    popsize : int, optional
        A multiplier for setting the total population size.  The population has
        ``popsize * len(x)`` individuals (unless the initial population is
        supplied via the `init` keyword).
    tol : float, optional
        Relative tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    mutation : float or tuple(float, float), optional
        The mutation constant. In the literature this is also known as
        differential weight, being denoted by F.
        If specified as a float it should be in the range [0, 2].
        If specified as a tuple ``(min, max)`` dithering is employed. Dithering
        randomly changes the mutation constant on a generation by generation
        basis. The mutation constant for that generation is taken from
        ``U[min, max)``. Dithering can help speed convergence significantly.
        Increasing the mutation constant increases the search radius, but will
        slow down convergence.
    recombination : float, optional
        The recombination constant, should be in the range [0, 1]. In the
        literature this is also known as the crossover probability, being
        denoted by CR. Increasing this value allows a larger number of mutants
        to progress into the next generation, but at the risk of population
        stability.
    seed : int or `np.random.RandomState`, optional
        If `seed` is not specified the `np.RandomState` singleton is used.
        If `seed` is an int, a new `np.random.RandomState` instance is used,
        seeded with seed.
        If `seed` is already a `np.random.RandomState instance`, then that
        `np.random.RandomState` instance is used.
        Specify `seed` for repeatable minimizations.
    disp : bool, optional
        Display status messages
    callback : callable, `callback(xk, convergence=val)`, optional
        A function to follow the progress of the minimization. ``xk`` is
        the current value of ``x0``. ``val`` represents the fractional
        value of the population convergence.  When ``val`` is greater than one
        the function halts. If callback returns `True`, then the minimization
        is halted (any polishing is still carried out).
    polish : bool, optional
        If True (default), then `scipy.optimize.minimize` with the `L-BFGS-B`
        method is used to polish the best population member at the end, which
        can improve the minimization slightly.
    init : str or array-like, optional
        Specify which type of population initialization is performed. Should be
        one of:
            - 'latinhypercube'
            - 'random'
            - array specifying the initial population. The array should have
              shape ``(M, len(x))``, where len(x) is the number of parameters.
              `init` is clipped to `bounds` before use.
        The default is 'latinhypercube'. Latin Hypercube sampling tries to
        maximize coverage of the available parameter space. 'random'
        initializes the population randomly - this has the drawback that
        clustering can occur, preventing the whole of parameter space being
        covered. Use of an array to specify a population subset could be used,
        for example, to create a tight bunch of initial guesses in an location
        where the solution is known to exist, thereby reducing time for
        convergence.
    atol : float, optional
        Absolute tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    Returns
    -------
    res : OptimizeResult
        The optimization result represented as a `OptimizeResult` object.
        Important attributes are: ``x`` the solution array, ``success`` a
        Boolean flag indicating if the optimizer exited successfully and
        ``message`` which describes the cause of the termination. See
        `OptimizeResult` for a description of other attributes.  If `polish`
        was employed, and a lower minimum was obtained by the polishing, then
        OptimizeResult also contains the ``jac`` attribute.
    Notes
    -----
    Differential evolution is a stochastic population based method that is
    useful for global optimization problems. At each pass through the population
    the algorithm mutates each candidate solution by mixing with other candidate
    solutions to create a trial candidate. There are several strategies [2]_ for
    creating trial candidates, which suit some problems more than others. The
    'best1bin' strategy is a good starting point for many systems. In this
    strategy two members of the population are randomly chosen. Their difference
    is used to mutate the best member (the `best` in `best1bin`), :math:`b_0`,
    so far:
    .. math::
        b' = b_0 + mutation * (population[rand0] - population[rand1])
    A trial vector is then constructed. Starting with a randomly chosen 'i'th
    parameter the trial is sequentially filled (in modulo) with parameters from
    `b'` or the original candidate. The choice of whether to use `b'` or the
    original candidate is made with a binomial distribution (the 'bin' in
    'best1bin') - a random number in [0, 1) is generated.  If this number is
    less than the `recombination` constant then the parameter is loaded from
    `b'`, otherwise it is loaded from the original candidate.  The final
    parameter is always loaded from `b'`.  Once the trial candidate is built
    its fitness is assessed. If the trial is better than the original candidate
    then it takes its place. If it is also better than the best overall
    candidate it also replaces that.
    To improve your chances of finding a global minimum use higher `popsize`
    values, with higher `mutation` and (dithering), but lower `recombination`
    values. This has the effect of widening the search radius, but slowing
    convergence.
    .. versionadded:: 0.15.0
    Examples
    --------
    Let us consider the problem of minimizing the Rosenbrock function. This
    function is implemented in `rosen` in `scipy.optimize`.
    >>> from scipy.optimize import rosen, differential_evolution
    >>> bounds = [(0,2), (0, 2), (0, 2), (0, 2), (0, 2)]
    >>> result = differential_evolution(rosen, bounds)
    >>> result.x, result.fun
    (array([1., 1., 1., 1., 1.]), 1.9216496320061384e-19)
    Next find the minimum of the Ackley function
    (http://en.wikipedia.org/wiki/Test_functions_for_optimization).
    >>> from scipy.optimize import differential_evolution
    >>> import numpy as np
    >>> def ackley(x):
    ...     arg1 = -0.2 * np.sqrt(0.5 * (x[0] ** 2 + x[1] ** 2))
    ...     arg2 = 0.5 * (np.cos(2. * np.pi * x[0]) + np.cos(2. * np.pi * x[1]))
    ...     return -20. * np.exp(arg1) - np.exp(arg2) + 20. + np.e
    >>> bounds = [(-5, 5), (-5, 5)]
    >>> result = differential_evolution(ackley, bounds)
    >>> result.x, result.fun
    (array([ 0.,  0.]), 4.4408920985006262e-16)
    References
    ----------
    .. [1] Storn, R and Price, K, Differential Evolution - a Simple and
           Efficient Heuristic for Global Optimization over Continuous Spaces,
           Journal of Global Optimization, 1997, 11, 341 - 359.
    .. [2] http://www1.icsi.berkeley.edu/~storn/code.html
    .. [3] http://en.wikipedia.org/wiki/Differential_evolution
    """

    solver = DifferentialEvolutionSolver(func, bounds, args=args,
                                         strategy=strategy, maxiter=maxiter,
                                         popsize=popsize, tol=tol,
                                         mutation=mutation,
                                         recombination=recombination,
                                         seed=seed, polish=polish,
                                         callback=callback,
                                         disp=disp, init=init, atol=atol)
    return solver.solve()


class DifferentialEvolutionSolver(object):

    """This class implements the differential evolution solver
    Parameters
    ----------
    func : callable
        The objective function to be minimized.  Must be in the form
        ``f(x, *args)``, where ``x`` is the argument in the form of a 1-D array
        and ``args`` is a  tuple of any additional fixed parameters needed to
        completely specify the function.
    bounds : sequence
        Bounds for variables.  ``(min, max)`` pairs for each element in ``x``,
        defining the lower and upper bounds for the optimizing argument of
        `func`. It is required to have ``len(bounds) == len(x)``.
        ``len(bounds)`` is used to determine the number of parameters in ``x``.
    args : tuple, optional
        Any additional fixed parameters needed to
        completely specify the objective function.
    strategy : str, optional
        The differential evolution strategy to use. Should be one of:
            - 'best1bin'
            - 'best1exp'
            - 'rand1exp'
            - 'randtobest1exp'
            - 'currenttobest1exp'
            - 'best2exp'
            - 'rand2exp'
            - 'randtobest1bin'
            - 'currenttobest1bin'
            - 'best2bin'
            - 'rand2bin'
            - 'rand1bin'
        The default is 'best1bin'
    maxiter : int, optional
        The maximum number of generations over which the entire population is
        evolved. The maximum number of function evaluations (with no polishing)
        is: ``(maxiter + 1) * popsize * len(x)``
    popsize : int, optional
        A multiplier for setting the total population size.  The population has
        ``popsize * len(x)`` individuals (unless the initial population is
        supplied via the `init` keyword).
    tol : float, optional
        Relative tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    mutation : float or tuple(float, float), optional
        The mutation constant. In the literature this is also known as
        differential weight, being denoted by F.
        If specified as a float it should be in the range [0, 2].
        If specified as a tuple ``(min, max)`` dithering is employed. Dithering
        randomly changes the mutation constant on a generation by generation
        basis. The mutation constant for that generation is taken from
        U[min, max). Dithering can help speed convergence significantly.
        Increasing the mutation constant increases the search radius, but will
        slow down convergence.
    recombination : float, optional
        The recombination constant, should be in the range [0, 1]. In the
        literature this is also known as the crossover probability, being
        denoted by CR. Increasing this value allows a larger number of mutants
        to progress into the next generation, but at the risk of population
        stability.
    seed : int or `np.random.RandomState`, optional
        If `seed` is not specified the `np.random.RandomState` singleton is
        used.
        If `seed` is an int, a new `np.random.RandomState` instance is used,
        seeded with `seed`.
        If `seed` is already a `np.random.RandomState` instance, then that
        `np.random.RandomState` instance is used.
        Specify `seed` for repeatable minimizations.
    disp : bool, optional
        Display status messages
    callback : callable, `callback(xk, convergence=val)`, optional
        A function to follow the progress of the minimization. ``xk`` is
        the current value of ``x0``. ``val`` represents the fractional
        value of the population convergence.  When ``val`` is greater than one
        the function halts. If callback returns `True`, then the minimization
        is halted (any polishing is still carried out).
    polish : bool, optional
        If True, then `scipy.optimize.minimize` with the `L-BFGS-B` method
        is used to polish the best population member at the end. This requires
        a few more function evaluations.
    maxfun : int, optional
        Set the maximum number of function evaluations. However, it probably
        makes more sense to set `maxiter` instead.
    init : str or array-like, optional
        Specify which type of population initialization is performed. Should be
        one of:
            - 'latinhypercube'
            - 'random'
            - array specifying the initial population. The array should have
              shape ``(M, len(x))``, where len(x) is the number of parameters.
              `init` is clipped to `bounds` before use.
        The default is 'latinhypercube'. Latin Hypercube sampling tries to
        maximize coverage of the available parameter space. 'random'
        initializes the population randomly - this has the drawback that
        clustering can occur, preventing the whole of parameter space being
        covered. Use of an array to specify a population could be used, for
        example, to create a tight bunch of initial guesses in an location
        where the solution is known to exist, thereby reducing time for
        convergence.
    atol : float, optional
        Absolute tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    """

    # Dispatch of mutation strategy method (binomial or exponential).
    _binomial = {'best1bin': '_best1',
                 'randtobest1bin': '_randtobest1',
                 'currenttobest1bin': '_currenttobest1',
                 'best2bin': '_best2',
                 'rand2bin': '_rand2',
                 'rand1bin': '_rand1'}
    _exponential = {'best1exp': '_best1',
                    'rand1exp': '_rand1',
                    'randtobest1exp': '_randtobest1',
                    'currenttobest1exp': '_currenttobest1',
                    'best2exp': '_best2',
                    'rand2exp': '_rand2'}

    __init_error_msg = ("The population initialization method must be one of "
                        "'latinhypercube' or 'random', or an array of shape "
                        "(M, N) where N is the number of parameters and M>5")

    def __init__(self, func, bounds, args=(),
                 strategy='best1bin', maxiter=1000, popsize=15,
                 tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=None,
                 maxfun=np.inf, callback=None, disp=False, polish=True,
                 init='latinhypercube', atol=0):

        if strategy in self._binomial:
            self.mutation_func = getattr(self, self._binomial[strategy])
        elif strategy in self._exponential:
            self.mutation_func = getattr(self, self._exponential[strategy])
        else:
            raise ValueError("Please select a valid mutation strategy")
        self.strategy = strategy

        self.callback = callback
        self.polish = polish

        # relative and absolute tolerances for convergence
        self.tol, self.atol = tol, atol

        # Mutation constant should be in [0, 2). If specified as a sequence
        # then dithering is performed.
        self.scale = mutation
        if (not np.all(np.isfinite(mutation)) or
                np.any(np.array(mutation) >= 2) or
                np.any(np.array(mutation) < 0)):
            raise ValueError('The mutation constant must be a float in '
                             'U[0, 2), or specified as a tuple(min, max)'
                             ' where min < max and min, max are in U[0, 2).')

        self.dither = None
        if hasattr(mutation, '__iter__') and len(mutation) > 1:
            self.dither = [mutation[0], mutation[1]]
            self.dither.sort()

        self.cross_over_probability = recombination

        self.func = func
        self.args = args

        # convert tuple of lower and upper bounds to limits
        # [(low_0, high_0), ..., (low_n, high_n]
        #     -> [[low_0, ..., low_n], [high_0, ..., high_n]]
        self.limits = np.array(bounds, dtype='float').T
        if (np.size(self.limits, 0) != 2 or not
                np.all(np.isfinite(self.limits))):
            raise ValueError('bounds should be a sequence containing '
                             'real valued (min, max) pairs for each value'
                             ' in x')

        if maxiter is None:  # the default used to be None
            maxiter = 1000
        self.maxiter = maxiter
        if maxfun is None:  # the default used to be None
            maxfun = np.inf
        self.maxfun = maxfun

        # population is scaled to between [0, 1].
        # We have to scale between parameter <-> population
        # save these arguments for _scale_parameter and
        # _unscale_parameter. This is an optimization
        self.__scale_arg1 = 0.5 * (self.limits[0] + self.limits[1])
        self.__scale_arg2 = np.fabs(self.limits[0] - self.limits[1])

        self.parameter_count = np.size(self.limits, 1)

        self.random_number_generator = check_random_state(seed)

        # default population initialization is a latin hypercube design, but
        # there are other population initializations possible.
        # the minimum is 5 because 'best2bin' requires a population that's at
        # least 5 long
        self.num_population_members = max(5, popsize * self.parameter_count)

        self.population_shape = (self.num_population_members,
                                 self.parameter_count)

        self._nfev = 0
        if isinstance(init, str):
            if init == 'latinhypercube':
                self.init_population_lhs()
            elif init == 'random':
                self.init_population_random()
            else:
                raise ValueError(self.__init_error_msg)
        else:
            self.init_population_array(init)

        self.disp = disp

    def init_population_lhs(self):
        """
        Initializes the population with Latin Hypercube Sampling.
        Latin Hypercube Sampling ensures that each parameter is uniformly
        sampled over its range.
        """
        rng = self.random_number_generator

        # Each parameter range needs to be sampled uniformly. The scaled
        # parameter range ([0, 1)) needs to be split into
        # `self.num_population_members` segments, each of which has the following
        # size:
        segsize = 1.0 / self.num_population_members

        # Within each segment we sample from a uniform random distribution.
        # We need to do this sampling for each parameter.
        samples = (segsize * rng.random_sample(self.population_shape)

                   # Offset each segment to cover the entire parameter range [0, 1)
                   + np.linspace(0., 1., self.num_population_members,
                                 endpoint=False)[:, np.newaxis])

        # Create an array for population of candidate solutions.
        self.population = np.zeros_like(samples)

        # Initialize population of candidate solutions by permutation of the
        # random samples.
        for j in range(self.parameter_count):
            order = rng.permutation(range(self.num_population_members))
            self.population[:, j] = samples[order, j]

        # reset population energies
        self.population_energies = (np.ones(self.num_population_members) *
                                    np.inf)

        # reset number of function evaluations counter
        self._nfev = 0

    def init_population_random(self):
        """
        Initialises the population at random.  This type of initialization
        can possess clustering, Latin Hypercube sampling is generally better.
        """
        rng = self.random_number_generator
        self.population = rng.random_sample(self.population_shape)

        # reset population energies
        self.population_energies = (np.ones(self.num_population_members) *
                                    np.inf)

        # reset number of function evaluations counter
        self._nfev = 0

    def init_population_array(self, init):
        """
        Initialises the population with a user specified population.
        Parameters
        ----------
        init : np.ndarray
            Array specifying subset of the initial population. The array should
            have shape (M, len(x)), where len(x) is the number of parameters.
            The population is clipped to the lower and upper `bounds`.
        """
        # make sure you're using a float array
        popn = np.asfarray(init)

        if (np.size(popn, 0) < 5 or
                popn.shape[1] != self.parameter_count or
                len(popn.shape) != 2):
            raise ValueError("The population supplied needs to have shape"
                             " (M, len(x)), where M > 4.")

        # scale values and clip to bounds, assigning to population
        self.population = np.clip(self._unscale_parameters(popn), 0, 1)

        self.num_population_members = np.size(self.population, 0)

        self.population_shape = (self.num_population_members,
                                 self.parameter_count)

        # reset population energies
        self.population_energies = (np.ones(self.num_population_members) *
                                    np.inf)

        # reset number of function evaluations counter
        self._nfev = 0

    @property
    def x(self):
        """
        The best solution from the solver
        Returns
        -------
        x : ndarray
            The best solution from the solver.
        """
        return self._scale_parameters(self.population[0])

    @property
    def convergence(self):
        """
        The standard deviation of the population energies divided by their
        mean.
        """
        return (np.std(self.population_energies) /
                np.abs(np.mean(self.population_energies) + _MACHEPS))

    def solve(self):
        """
        Runs the DifferentialEvolutionSolver.
        Returns
        -------
        res : OptimizeResult
            The optimization result represented as a ``OptimizeResult`` object.
            Important attributes are: ``x`` the solution array, ``success`` a
            Boolean flag indicating if the optimizer exited successfully and
            ``message`` which describes the cause of the termination. See
            `OptimizeResult` for a description of other attributes.  If `polish`
            was employed, and a lower minimum was obtained by the polishing,
            then OptimizeResult also contains the ``jac`` attribute.
        """
        nit, warning_flag = 0, False
        status_message = _status_message['success']

        # The population may have just been initialized (all entries are
        # np.inf). If it has you have to calculate the initial energies.
        # Although this is also done in the evolve generator it's possible
        # that someone can set maxiter=0, at which point we still want the
        # initial energies to be calculated (the following loop isn't run).
        if np.all(np.isinf(self.population_energies)):
            self._calculate_population_energies()

        # do the optimisation.
        for nit in range(1, self.maxiter + 1):
            # evolve the population by a generation
            try:
                next(self)
            except StopIteration:
                warning_flag = True
                status_message = _status_message['maxfev']
                break

            if self.disp:
                print("differential_evolution step %d: f(x)= %g"
                      % (nit,
                         self.population_energies[0]))

            # should the solver terminate?
            convergence = self.convergence

            if (self.callback and
                    self.callback(self._scale_parameters(self.population[0]),
                                  convergence=self.tol / convergence) is True):

                warning_flag = True
                status_message = ('callback function requested stop early '
                                  'by returning True')
                break

            intol = (np.std(self.population_energies) <=
                     self.atol +
                     self.tol * np.abs(np.mean(self.population_energies)))
            if warning_flag or intol:
                break

        else:
            status_message = _status_message['maxiter']
            warning_flag = True

        DE_result = OptimizeResult(
            x=self.x,
            fun=self.population_energies[0],
            nfev=self._nfev,
            nit=nit,
            message=status_message,
            success=(warning_flag is not True))

        if self.polish:
            result = minimize(self.func,
                              np.copy(DE_result.x),
                              method='L-BFGS-B',
                              bounds=self.limits.T,
                              args=self.args)

            self._nfev += result.nfev
            DE_result.nfev = self._nfev

            if result.fun < DE_result.fun:
                DE_result.fun = result.fun
                DE_result.x = result.x
                DE_result.jac = result.jac
                # to keep internal state consistent
                self.population_energies[0] = result.fun
                self.population[0] = self._unscale_parameters(result.x)

        return DE_result

    def _calculate_population_energies(self):
        """
        Calculate the energies of all the population members at the same time.
        Puts the best member in first place. Useful if the population has just
        been initialised.
        """

        ##############
        # CHANGES: self.func operates on the entire parameters array
        ##############
        itersize = max(0, min(len(self.population),
                       self.maxfun - self._nfev + 1))
        candidates = self.population[:itersize]
        parameters = np.array([self._scale_parameters(c)
                              for c in candidates])  # TODO: can be vectorized
        energies = self.func(parameters, *self.args)
        self.population_energies = energies
        self._nfev += itersize

        # for index, candidate in enumerate(self.population):
        #     if self._nfev > self.maxfun:
        #         break

        #     parameters = self._scale_parameters(candidate)
        #     self.population_energies[index] = self.func(parameters,
        #                                                 *self.args)
        #     self._nfev += 1

        ##############
        ##############

        minval = np.argmin(self.population_energies)

        # put the lowest energy into the best solution position.
        lowest_energy = self.population_energies[minval]
        self.population_energies[minval] = self.population_energies[0]
        self.population_energies[0] = lowest_energy

        self.population[[0, minval], :] = self.population[[minval, 0], :]

    def __iter__(self):
        return self

    def __next__(self):
        """
        Evolve the population by a single generation
        Returns
        -------
        x : ndarray
            The best solution from the solver.
        fun : float
            Value of objective function obtained from the best solution.
        """
        # the population may have just been initialized (all entries are
        # np.inf). If it has you have to calculate the initial energies
        if np.all(np.isinf(self.population_energies)):
            self._calculate_population_energies()

        if self.dither is not None:
            self.scale = (self.random_number_generator.rand()
                          * (self.dither[1] - self.dither[0]) + self.dither[0])

        ##############
        # CHANGES: self.func operates on the entire parameters array
        ##############

        itersize = max(0, min(self.num_population_members,
                       self.maxfun - self._nfev + 1))
        trials = np.array([self._mutate(c)
                          for c in range(itersize)])  # TODO: can be vectorized
        for trial in trials:
            self._ensure_constraint(trial)
        parameters = np.array([self._scale_parameters(trial)
                              for trial in trials])
        energies = self.func(parameters, *self.args)
        self._nfev += itersize

        for candidate, (energy, trial) in enumerate(zip(energies, trials)):
            # if the energy of the trial candidate is lower than the
            # original population member then replace it
            if energy < self.population_energies[candidate]:
                self.population[candidate] = trial
                self.population_energies[candidate] = energy

                # if the trial candidate also has a lower energy than the
                # best solution then replace that as well
                if energy < self.population_energies[0]:
                    self.population_energies[0] = energy
                    self.population[0] = trial

        # for candidate in range(self.num_population_members):
        #     if self._nfev > self.maxfun:
        #         raise StopIteration

        #     # create a trial solution
        #     trial = self._mutate(candidate)

        #     # ensuring that it's in the range [0, 1)
        #     self._ensure_constraint(trial)

        #     # scale from [0, 1) to the actual parameter value
        #     parameters = self._scale_parameters(trial)

        #     # determine the energy of the objective function
        #     energy = self.func(parameters, *self.args)
        #     self._nfev += 1

        #     # if the energy of the trial candidate is lower than the
        #     # original population member then replace it
        #     if energy < self.population_energies[candidate]:
        #         self.population[candidate] = trial
        #         self.population_energies[candidate] = energy

        #         # if the trial candidate also has a lower energy than the
        #         # best solution then replace that as well
        #         if energy < self.population_energies[0]:
        #             self.population_energies[0] = energy
        #             self.population[0] = trial

        ##############
        ##############

        return self.x, self.population_energies[0]

    def next(self):
        """
        Evolve the population by a single generation
        Returns
        -------
        x : ndarray
            The best solution from the solver.
        fun : float
            Value of objective function obtained from the best solution.
        """
        # next() is required for compatibility with Python2.7.
        return self.__next__()

    def _scale_parameters(self, trial):
        """
        scale from a number between 0 and 1 to parameters.
        """
        return self.__scale_arg1 + (trial - 0.5) * self.__scale_arg2

    def _unscale_parameters(self, parameters):
        """
        scale from parameters to a number between 0 and 1.
        """
        return (parameters - self.__scale_arg1) / self.__scale_arg2 + 0.5

    def _ensure_constraint(self, trial):
        """
        make sure the parameters lie between the limits
        """
        for index in np.where((trial < 0) | (trial > 1))[0]:
            trial[index] = self.random_number_generator.rand()

    def _mutate(self, candidate):
        """
        create a trial vector based on a mutation strategy
        """
        trial = np.copy(self.population[candidate])

        rng = self.random_number_generator

        fill_point = rng.randint(0, self.parameter_count)

        if self.strategy in ['currenttobest1exp', 'currenttobest1bin']:
            bprime = self.mutation_func(candidate,
                                        self._select_samples(candidate, 5))
        else:
            bprime = self.mutation_func(self._select_samples(candidate, 5))

        if self.strategy in self._binomial:
            crossovers = rng.rand(self.parameter_count)
            crossovers = crossovers < self.cross_over_probability
            # the last one is always from the bprime vector for binomial
            # If you fill in modulo with a loop you have to set the last one to
            # true. If you don't use a loop then you can have any random entry
            # be True.
            crossovers[fill_point] = True
            trial = np.where(crossovers, bprime, trial)
            return trial

        elif self.strategy in self._exponential:
            i = 0
            while (i < self.parameter_count and
                   rng.rand() < self.cross_over_probability):

                trial[fill_point] = bprime[fill_point]
                fill_point = (fill_point + 1) % self.parameter_count
                i += 1

            return trial

    def _best1(self, samples):
        """
        best1bin, best1exp
        """
        r0, r1 = samples[:2]
        return (self.population[0] + self.scale *
                (self.population[r0] - self.population[r1]))

    def _rand1(self, samples):
        """
        rand1bin, rand1exp
        """
        r0, r1, r2 = samples[:3]
        return (self.population[r0] + self.scale *
                (self.population[r1] - self.population[r2]))

    def _randtobest1(self, samples):
        """
        randtobest1bin, randtobest1exp
        """
        r0, r1, r2 = samples[:3]
        bprime = np.copy(self.population[r0])
        bprime += self.scale * (self.population[0] - bprime)
        bprime += self.scale * (self.population[r1] -
                                self.population[r2])
        return bprime

    def _currenttobest1(self, candidate, samples):
        """
        currenttobest1bin, currenttobest1exp
        """
        r0, r1 = samples[:2]
        bprime = (self.population[candidate] + self.scale *
                  (self.population[0] - self.population[candidate] +
                   self.population[r0] - self.population[r1]))
        return bprime

    def _best2(self, samples):
        """
        best2bin, best2exp
        """
        r0, r1, r2, r3 = samples[:4]
        bprime = (self.population[0] + self.scale *
                  (self.population[r0] + self.population[r1] -
                   self.population[r2] - self.population[r3]))

        return bprime

    def _rand2(self, samples):
        """
        rand2bin, rand2exp
        """
        r0, r1, r2, r3, r4 = samples
        bprime = (self.population[r0] + self.scale *
                  (self.population[r1] + self.population[r2] -
                   self.population[r3] - self.population[r4]))

        return bprime

    def _select_samples(self, candidate, number_samples):
        """
        obtain random integers from range(self.num_population_members),
        without replacement.  You can't have the original candidate either.
        """
        idxs = list(range(self.num_population_members))
        idxs.remove(candidate)
        self.random_number_generator.shuffle(idxs)
        idxs = idxs[:number_samples]
        return idxs

Prev Home Next

One Pixel Attack With Differential Evolution

One Pixel Attack With Differential Evolution

题目复述

差分演化

具体流程

调参

Copilot带来的问题

输出

性能比较

exp

Comments