摘要

1.Introduction

(a)我们在VGG16 model的最后一个卷积映射(conv5)上使用3x3的空间窗口密集滑动．每一行的序列窗口使用双向LSTM(BLSTM)递归连接．每一个窗口的卷积特征(3x3xC)作为256维BLSTM的输入(包括两个128维的LSTM).RNN layer再连接到一个512维的全连接层，紧接着是输出层，输出层连接着预测文本/非文本的得分，ｙ坐标轴以及k个锚的侧面细化偏移．(b)CTPN输出了序列化的固定宽度的精细化的文本候选框,每一个方框的颜色表明了文本/非文本的得分．只有得分为正的方框才会被显示出来．

    最近的文本检测方法大多采用自底向上的流程．[28,1,14,32,33]它们一般从低层次字符或者笔划开始检测，通常后面跟着许多后续步骤:非文本部分的过滤，文本行构造以及文本行验证．这些多步骤的自底向上的方法通常非常复杂，并且鲁棒性，可靠性较低．这些方法的性能非常依赖于字符检测的结果，以及已经提出的组成连接方法或者滑窗方法．这些方法通常探索低层次特征(比如基于SWT[3,13],MSER [14,33,23], or HoG [28])以从背景中区分出候选文本．然而由于其单独识别每个字符或者笔划，没有利用上下文信息，因此鲁棒性较低．举个例子，对于人来说识别序列字符要比识别单个字符更有自信，特别是当一个字符非常模糊的时候．这些限制经常会导致字符检测中巨大的非文本成分，这是导致后续步骤处理困难的主要原因．更进一步，这些错误的检测很容易在自底向上的处理步骤中累计，正如[28]指出的那样．为了解决这些问题，我们使用了强大的深层特征直接在卷积maps中进行文本信息的检测.我们提出了文本锚机制可以精细准确地预测文本的位置．然后，我们提出了一个in-netword recurrent 架构来连接这些精细化的文本候选框表达为序列化的形式，允许其编码成丰富的上下文信息．
    CNN最近极大地推动了一般物体检测的发展．[25,5,6]最近最先进的方法是Faster-Region-CNN(Faster RCNN)[25],

原文地址:DeepFM: A Factorization-Machine based Neural Network for CTR Prediction

1.echo和if else fi命令

1
2
3
4
5
6
7
8
9

#!/bin/bash
echo hello;echo there
filename=demo.sh
if [ -e "$filename" ]; then 
    echo "$filename already exists!";cp $filename $filename.bak
else
    echo "$filename does not exist!";
fi;
echo "File test complete!"

运行结果(demo.sh不存在):

1
2
3
4

hello
there
demo.sh does not exist!
File test complete!

需要注意的是filename=demo.sh等号两边是不能有空格的;if [ -e "$filename" ]中[]左右两侧都是有空格的。

2.shell基本操作

2.1 变量大于，等于，小于

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/bin/bash
a=1
if [ $a -gt 0 ]; then
    echo "greater than zero!"
else
    echo "no more than zero!"
fi
if [[ $a -lt 0 ]]; then
    echo "less than zero!"
else
    echo "no less than zero!"
fi
if [[ a -eq 1 ]]; then
    echo "equal to 1!"
else
    echo "not equal to 1!"
fi

-gt表示大于;-lt表示小于;-eq表示等于。运行结果为:

1
2
3

greater than zero!
no less than zero!
equal to 1!

2.2 三目运算符(?:)

1
2
3
4
5
6
7

# ? is 3 operator
b=10
((t=b<20?6:4)) # t = 6
echo "t=$t"
# variable in () is a part region variable
(b=20;echo "b = $b") # b = 20
echo "b = $b" # b = 10

和C,java等语言类似,shell中的?:也是三目运算符。()表示一个建立局部作用域,可以暂时屏蔽全局变量。上式的运行结果为:

1
2
3

t=6
b = 20
b = 10

2.3 数组

2.3.1 数组创建

1
2
3

# () create an array
arr=(1 2 3 5 6)
echo "arr[3] = ${arr[3]}"

输出:

1

arr[3] = 5

2.3.2 数组长度

1
2
3

# get the length of array
echo "length of arr is ${#arr[*]}" # 5
echo "length of arr is ${#arr[@]}" # 5

输出:

1
2
3
4
5
6
7
8
9

length of arr is 5
length of arr is 5
``` 
##### 2.3.3 输出数组元素
```shell 
# get all content of array
echo "arr:${arr[*]}" # 1 2 3 5 6
# or
echo "arr:${arr[@]}" # 1 2 3 5 6

输出:

1
2

arr:1 2 3 5 6
arr:1 2 3 5 6

2.3.4 修改数组元素

1
2
3
4
5
6

# assign a new element to an array
arr[1]=100
echo "arr:${arr[@]}" # 1 100 3 5 6
# if assign index if out of bound,then auto create a new element of array
arr[10]=20 # 1 100 3 5 6 20
echo "arr:${arr[@]}"

输出:

1
2

arr:1 100 3 5 6
arr:1 100 3 5 6 20

注意如果赋值索引超出数组长度，相当于是给数组末尾增加一个新元素。

2.3.5 删除数组元素

1
2
3
4
5
6

# delete the element of array
unset arr[1] # delete the arr[1],1 3 5 6 20
echo "arr:${arr[*]}" # 1 3 5 6 20
# clear the whole array
unset arr 
echo "${#arr[@]}" # length 0

输出:

1
2

arr:1 3 5 6 20
0

unset 如果跟上数组的索引，是删除该位置的数组元素;如果直接跟数组名，相当于是清空数组。

2.3.6 数组切片

1
2
3
4
5
6
7
8

arr=(1 2 4 10)
# slice of array
# ${array_name[*]:start:length},return is a string
echo "${arr[@]:0:3}" # 1 2 4
# assignment
arr1=(${arr[*]:1:2}) # arr1:2 4
echo "${#arr1[@]}"
echo "arr1:${arr1[@]}"

输出:

1
2
3

1 2 4
2
arr1:2 4

2.3.7 数组元素替换

1
2
3
4
5
6
7

# replace
# ${array_name[@]/origin_element/new_element}
# this operation doesn't change the origin array
# and will return a string that seperated by space
echo "${arr1[*]/2/20}" # 20 4,arr1:2 4
arr1=(${arr1[*]/4/40}) # arr1:2 40
echo "${arr1[*]}" # 2 40

输出:

1
2

20 4
2 40

2.4 文件操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# file operation
if [ ! -w 't.txt' ]; then
	touch t.txt
fi
echo 'test text' > t.txt 
cp t.{txt,back} # cp t.txt to t.back
filename="/home/lyrichu/login"
if [ -r $filename ] # if file is readable
	then 
	echo "$filename is readable!"
else
	echo "$filename is not readable!"
fi

if [ -e $filename ]
	then
	echo "$filename exists!"
else
	echo "$filename doesn't exist!"
fi

输出:

1
2

/home/lyrichu/login is not readable!
/home/lyrichu/login doesn't exist!

上面的代码首先检查t.txt文件是否可写，如果不可写，则重新创建一个文件;然后向t.txt文件写入字符串’test text’;接着复制t.txt文件到t.back文件;
然后判断/home/lyrichu/login文件是否可读以及是否存在。

2.5 {}创建一个代码块

1
2
3
4

# {} create a code block
a=10;echo "a=$a"
{ a=20; } # a = 20
echo "a=$a" # a = 20

输出:

1
2

a=10
a=20

2.6 expr 计算表达式的值

1
2
3
4
5
6
7
8
9
10
11
12
13

val=`expr $a + $b` # a = 20,b = 10
echo "a + b = $val" # a + b = 30

val=`expr $a \* $b` # \* means multiply,a*b = 10*20 = 200
echo "a*b=$val"

# divide
val=`expr $a / $b` # 20/10 = 2
echo "a / b = $val"

# mod
val=`expr $a % 9` # 20 % 9 = 2
echo "$a % 9 = $val" # 20 % 9 = 2

输出:

1
2
3
4

a + b = 30
a*b=200
a / b = 2
20 % 9 = 2

expr可以计算shell表达式的值,上式分别计算了+,*,/,%运算，注意乘法需要使用\*转义。

2.7 逻辑运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

if [ $a == $b ]
then echo "a == b!"
fi
if [ $a != $b ] 
	then 
	echo "a != b" 
fi 

# && logit and
if [[ $a -gt 10 && $b -lt 20 ]]
	then
	echo "$a > 10 and $b < 20!"
else
	echo "bad condition!"
fi
# || logit or 
if [[ $a -gt 15 || $b -gt 15 ]]
	then
	echo "a > 15 or b > 15"
else
	echo "a<=15 and b<=15"
fi

输出:

1
2
3

a != b
20 > 10 and 10 < 20!
a > 15 or b > 15

== 用于比较数字相等;!=用于比较数字不等。&&表示shell中的逻辑与;||表示shell中的逻辑或运算。

2.8 字符串操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#!/bin/bash
s1="abhsgd"
# 获取字符串长度
echo "length of s1:" ${#s1}
#提取子字符串
# ${string:position},在string中，从position位置开始提取子字符串
echo ${s1:2} # hsgd
# ${string:position:length},string中，从position位置开始提取长度为length的子字符串
echo ${s1:2:2} # hs 
# ${string#substring},从string的开头, 删除最短匹配substring的子串,返回删除子串之后的字符串
echo ${s1#ab} #hsgd
# ${string##substring},从string的开头, 删除最长匹配substring的子串
echo ${s1##abh} # sgd
# ${string%substring},从string的结尾, 删除最短匹配substring的子串
echo ${s1%gd} # absh
# ${string%%substring},从string的结尾, 删除最长匹配substring的子串
echo ${s1%%hsgd} # ab
# ${string/substring/replacement},使用replacement,来代替第一个匹配的substring
echo ${s1/hs/HS} # abHSgd
# ${string//substring/replacement},使用replacement, 代替所有匹配的substring
s2=ahjhjhhshdg
echo ${s2//h/H} # aHjHjHHsHdg
# ${string/#substring/replacement},如果string的前缀匹配substring, 那么就用replacement来代替匹配到的substring
echo ${s2/#ahj/AHJ} # AHJhjhhshdg
# ${string/%substring/replacement},如果string的后缀匹配substring, 那么就用replacement来代替匹配到的substring
echo ${s2/%shdg/SHDG} # ahjhjhhSHDG
## 注:上面replacement可以是正则表达式,比如:
s3=/home/lyrichu/demo.txt 
# 得到文件名
echo ${s3##*/} #demo.txt 
#　得到目录名
echo ${s3%/*} # /home/lyrichu

输出:

1
2
3
4
5
6
7
8
9
10
11
12
13

length of s1: 6
hsgd
hs
hsgd
sgd
abhs
ab
abHSgd
aHjHjHHsHdg
AHJhjhhshdg
ahjhjhhSHDG
demo.txt
/home/lyrichu

2.9 控制流

2.9.1 if语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

a=10
b=20
if [ $a == $b ]
	then
	echo "$a == $b !"
elif [[ $a -gt $b ]]; then
	echo "$a > $b!"
elif [[ $a -lt $b ]]; then
	echo "$a < $b!"
else
	echo "Error!"
fi

# test command
if test $a -lt $b
	then 
	echo "$a < $b!"
else
	echo "$a >= $b!"
fi

输出:

1
2

10 < 20!
10 < 20!

其中test命令用来判断一条语句的真假。

2.9.2 for 语句

1
2
3
4
5
6
7
8
9
10
11

# for loop
for i in 1 2 3 4
do
	echo "The value is $i"
done

# for loop of string
for s in This is a string
do
	echo "$s"
done

输出:

1
2
3
4
5
6
7
8

The value is 1
The value is 2
The value is 3
The value is 4
This
is
a
string

2.9.3 while 循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#while loop
i=1
while(( $i<5 ))
do
	echo "$i"
	let "i++"
done

echo "Press CTRL+D to exit!"
echo -n "Who is the most beautiful girl?"
while read MAN
do
	echo "Yes! $MAN is really beautiful!"
done

输出:

1
2
3
4
5
6
7

1
2
3
4
Press CTRL+D to exit!
Who is the most beautiful girl?yp
Yes! yp is really beautiful!

2.9.4 case 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# case mode
echo "Please input a number between 1 to 4!"
read input
case input in
	1) echo "Your choice is 1!"
	;;
	2) echo "Your choice is 2!"
	;;
	3) echo "Your choice is 3!"
	;;
	4) echo "Your choice is 4!"
	;;
	*) echo "You don't choose a number between 1 and 4!"
	;;
esac 

## break 
while :
do
	echo "PLease input a number between 1 and 5!"
	read n 
	case $n in 
		1|2|3|4|5) echo "Your input number is $n!"
		;;
		*) echo "Your input is not between 1 and 5!"
			break
		;;
	esac 
done

输出:

1
2
3
4
5
6
7
8
9

Please input a number between 1 to 4!
3
Your choice is 3!
PLease input a number between 1 and 5!
5
Your input number is 5!
PLease input a number between 1 and 5!
10
Your input is not between 1 and 5!

2.10 函数

2.10.1 一个简单的没有参数，没有返回值的函数

1
2
3
4
5

func1(){ # fuction that does not have parameters
	echo "This is my first function!"
}
# call function
func1

输出:

1

This is my first function!

2.10.2 带有返回值的函数

1
2
3
4
5
6
7

func2(){ # function with return
	echo "This is function that has return!"
	return 1
}
# use $? to get the function return value
func2
echo "The return value of func2 is $?"

输出:

1
2

This is function that has return!
The return value of func2 is 1

在末尾使用return关键字即可以返回一个值,使用$?来获取函数的返回值。

函数传递参数，获取参数总数，参数值以及第i个参数

1
2
3
4
5
6
7
8
9
10
11

# input parameters of function
# $1,$2,... to the first n parameter
func3(){
	n=$# # get the total number of parameters
	echo "There are total $n parameters of func3!"
	echo "The first parameter is:$1"
	echo "The second parameter is $2"
	echo "The tenth parameter is ${10}"
	echo "The all parameters as string is:$*"
}
func3 1 2 3 4 5 6 7 8 9 10 11 12

输出:

1
2
3
4
5

There are total 12 parameters of func3!
The first parameter is:1
The second parameter is 2
The tenth parameter is 10
The all parameters as string is:1 2 3 4 5 6 7 8 9 10 11 12

3.一些简单的shell 实例

3.1 计算３个数的最大值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# calculate the max value of 8,4,5
a=5
b=4
c=8
i=$a

if [[ $i -lt $b ]]
    then
    i=$b
fi

if [[ $i -lt $c ]]
    then
    i=$c
fi
echo "The max value of $a,$b,$c is $i"

输出:

1

The max value of 5,4,8 is 8

3.2 随机猜数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/bin/bash
# random generate a number between 1 and 3, and let you to
# guess the number's value,if you are right,then echo "You guess right!"
# else echo "You guess wrong!"
# use while to play the game,input "quit" to quit the game
# $RANDOM generate a number between 0 and 32767
while :
do
    r=$RANDOM
    r=`expr $r % 3 + 1` # between 1 and 3
    echo "Please input a number between 1 and 10(enter quit to quit the game):"
    read g
    if [[ $g = "quit" ]]
        then
        break
    elif [[ $g == $r ]]; then
        echo "You guess right!"
    else
        echo "You guess wrong!"
    fi
done

输出:

1
2
3
4
5
6
7
8
9
10
11

Please input a number between 1 and 10(enter quit to quit the game):
2
You guess right!
Please input a number between 1 and 10(enter quit to quit the game):
3
You guess right!
Please input a number between 1 and 10(enter quit to quit the game):
3
You guess wrong!
Please input a number between 1 and 10(enter quit to quit the game):
quit

3.3 求小于100的所有偶数的和

1
2
3
4
5
6
7
8
9

#!/bin/bash
# sum the even number that less than 100
i=2
s=0
while [[ $i -lt 100 ]]; do
    s=`expr $s + $i`
    i=`expr $i + 2`
done
echo "The even number that less than 100's sum is $s"

输出:

1

The even number that less than 100's sum is 2450

3.4 输出星号(*)金字塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/bin/bash
# output the pyramid of stars
for i in 4 3 2 1 0
do
    j=$i 
    while [[ $j -gt 0 ]]
    do
        echo -n " "
        let "j--"
    done
    j=`expr 9 - 2 \* $i`
    while [[ $j -gt 0 ]]
    do
        echo -n "*"
        let "j--"
    done
    j=$i 
    while [[ $j -gt 0 ]]
    do
        echo -n " "
        let "j--"
    done
    echo ""
done

输出:

1
2
3
4
5

    *    
   ***   
  *****  
 ******* 
*********

Reference

1. linux shell 字符串操作（长度，查找，替换）详解
2. linux shell 数组建立及使用技巧
3. (实验楼)高级 bash 脚本编程指南

    在用sublime+LatexTools一段时间之后，发现用它来写Latex真的是非常方便，配置好TexLive之后直接CTRL+B就可以直接编译运行了，so cool!但是最近写课程论文的时候，我在引用参考文献时碰到了一些麻烦。不怕大家笑话，本来我写参考文献都是直接手动标注[1],[2]…然后手动写参考文献的。一旦参考文献多起来，这简直要命。所以我这次终于决定换一种方式，看看有没有什么好办法可以自动导出参考文献的。一找，办法果然还是很多的。这里简单记录我使用的一种办法。
    首先，你需要维护一个.bib文件,里面是特定格式的你的参考文献。一般是如下的形式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@article{simonyan2015very,
    title="Very Deep Convolutional Networks for Large-Scale Image Recognition",
    author="Karen {Simonyan} and Andrew {Zisserman}",
    journal="international conference on learning representations",
    year="2015"
}

@inproceedings{krizhevsky2012imagenet,
    title="ImageNet Classification with Deep Convolutional Neural Networks",
    author="Alex {Krizhevsky} and Ilya {Sutskever} and Geoffrey E. {Hinton}",
    booktitle="Advances in Neural Information Processing Systems 25",
    pages="1097--1105",
    year="2012"
}

@inproceedings{he2016deep,
    title="Deep Residual Learning for Image Recognition",
    author="Kaiming {He} and Xiangyu {Zhang} and Shaoqing {Ren} and Jian {Sun}",
    booktitle="2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR)",
    pages="770--778",
    year="2016"
}

article,inproceedings等表示的是文献类型,simonyan2015very,he2016deep表示的参考文献的id,这个id必须必须是独一无二的，后面会使用\cite{simonyan2015very}这种形式来引用参考文献。你可能会问，上面.bib文件难道需要手动填写吗?当然不会啦，有一种最简便的方法可以自动生成.bib文件，那就是去google scholar(可能需要翻墙)或者bing scholar(推荐),搜索你引用的文献，它会自动生成.bib文件。以bing scholar为例，如图１所示:

1
2
3

\renewcommand\refname{参考文献} 
\bibliographystyle{plain}
\bibliography{mybibtex}

默认生成的参考文献名字是Reference,如果你的论文是用中文书写的话，第一行命令可以以参考文献命名;第二行是设置参考文献的格式;第三行mybibtex是你的.bib文件的名字(这里是mybibtex.bib,注意不需要.bib后缀)。如果你需要在文中的某个地方引用某篇参考文献的话，使用\cite{}命令会自动弹出所有的参考文献列表框，然后你选择相应的文献就可以自动引用了。引用是采用\cite{simonyan2015very}的形式，其中simonyan2015very是文献的id标识。我在实际操作的过程中遇到了bib files not found的问题。找了半天终于找到了问题，只需要在latex文件的首行加上% !TEX root = xxx.tex的命令即可,其中xxx.tex是你的latex源文件的名字。
    上面的步骤都完成之后，就可以编译latex文件了。这里如果使用普通的latex编译方式xelatex *.tex是没有办法成功生成参考文献的。需要依次执行如下的四个命令:

1
2
3
4

xelatex *.tex
bibtex *.aux
xelatex *.tex
xelatex *.tex

才可以成功编译。
    最后,你也可以参考知乎的这个回答:如何在LaTeX写作中管理参考文献?

• 遗传算法(Genetic Algorithm,GA)
• 粒子群算法(Particle Swarm Optimization,PSO)
• 模拟退火算法(Simulated Anealing,SA)
• 随机游走算法(Random Walk):
• 梯度下降法(Gradient Descent,GD)
• 动量优化算法(Momentum)
• 自适应梯度算法(AdaGrad)
• RMSProp
• Adam
  由于只是一个初步的版本，后续如果有时间的话，会加上更多的优化算法进去。目前所有的优化算法暂时只支持连续实函数的优化;除了基于梯度的几个优化算法,GA、PSO、SA以及Random Walk都同时支持无约束优化，线性约束优化以及非线性约束优化。具体我会在下面详细说明。
  

  sopt 使用详解以及实例演示

  
  

  1.SGA 使用

  
      SGA是Simple Genetic Algorithm的简称，是最基本的遗传算法。其编码方式采用二进制编码,选择方法采用轮盘赌法,交叉方法采用单点交叉,变异方式采用均匀变异,默认是求函数的最小值。下面是sopt中SGA的一个简单使用实例:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  from sopt.SGA import SGA from math import sin def func1(x): return (x[0]-1)**2 + (sin(x[1])-0.5)**4 + 2 if __name__ == '__main__': sga = SGA.SGA(func = func1,func_type = 'min',variables_num = 2, lower_bound = 0,upper_bound = 2,generations = 20, binary_code_length = 10) # run SGA sga.run() # show the SGA optimization result in figure sga.save_plot() # print the result sga.show_result()

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

-------------------- SGA config is: --------------------
lower_bound:[0, 0]
generations:20
cross_rate:0.7
variables_num:2
mutation_rate:0.1
func_type:min
upper_bound:[2, 2]
population_size:100
func:<function func1 at 0x7f3d2311b158>
binary_code_length:10
-------------------- SGA caculation result is: --------------------
global best generation index/total generations:3/20
global best point:[1.00488759 0.45356794]
global best target:2.00003849823336

用图像展示为图1所示:

• lower_bound:一个int或者float的数字，或者是长度为variables_num的ndarray,表示每个变量的下界,如果是一个数字的话，我们认为所有的下界都是一样的(必填);
• upper_bound:一个int或者float的数字，或者是长度为variables_num的ndarray,表示每个变量的上界,如果是一个数字的话，我们认为所有的上界都是一样的(必填);
• variables_num:表示目标函数变量的个数(必填);
• func(必填):表示目标函数;
• cross_rate:GA的交叉率,默认为0.7;
• mutation_rate:变异率,默认为0.1;
• population_size:种群数目,默认为100;
• generations:进化代数,默认是200;
• binary_code_length:GA二进制编码的长度,默认是10;
• func_type:函数优化类型,求最小值取值为’min’,求最大值取值为’max’,默认是’min’;
  

  2. GA 使用

  
      GA是相比SGA更加一般的遗传算法实现，其对于编码方式，选择方式，交叉方式以变异方式等会有更多的支持。首先还是看一个例子:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

  from sopt.GA.GA import GA from sopt.util.functions import * from sopt.util.ga_config import * from sopt.util.constraints import * class TestGA: def __init__(self): self.func = quadratic11 self.func_type = quadratic11_func_type self.variables_num = quadratic11_variables_num self.lower_bound = quadratic11_lower_bound self.upper_bound = quadratic11_upper_bound self.cross_rate = 0.8 self.mutation_rate = 0.05 self.generations = 200 self.population_size = 100 self.binary_code_length = 20 self.cross_rate_exp = 1 self.mutation_rate_exp = 1 self.code_type = code_type.binary self.cross_code = False self.select_method = select_method.proportion self.rank_select_probs = None self.tournament_num = 2 self.cross_method = cross_method.uniform self.arithmetic_cross_alpha = 0.1 self.arithmetic_cross_exp = 1 self.mutation_method = mutation_method.uniform self.none_uniform_mutation_rate = 1 #self.complex_constraints = [constraints1,constraints2,constraints3] self.complex_constraints = None self.complex_constraints_method = complex_constraints_method.penalty self.complex_constraints_C = 1e6 self.M = 1e8 self.GA = GA(**self.__dict__) def test(self): start_time = time() self.GA.run() print("GA costs %.4f seconds!" % (time()-start_time)) self.GA.save_plot() self.GA.show_result() if __name__ == '__main__': TestGA().test()

上面代码的运行结果为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

GA costs 6.8320 seconds!
-------------------- GA config is: --------------------
func:<function quadratic11 at 0x7f998927bd08>
code_type:binary
complex_constraints:None
global_generations_step:200
cross_method:uniform
mutation_method:uniform
cross_rate:0.8
lower_bound:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
tournament_num:2
variables_num:11
complex_constraints_method:penalty
none_uniform_mutation_rate:1
population_size:100
mutation_rate:0.05
generations:200
arithmetic_cross_alpha:0.1
func_type:min
mutation_rate_exp:1
cross_rate_exp:1
arithmetic_cross_exp:1
M:100000000.0
select_method:proportion
upper_bound:[11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11]
cross_code:False
binary_code_length:20
complex_constraints_C:1000000.0
-------------------- GA caculation result is: --------------------
global best target generation index/total generations:149/200
global best point:[ 1.07431037  2.41401426  2.4807906   4.36291634  4.90653029  6.13753427
  6.58147963  7.7370479   9.42957347 10.46616122 10.87151134]
global best target:2.2685208668743204

    其中sopt.util.functions预定义了一些测试函数,quadratic11是一个11元变量的二次函数，函数原型为:$quadratic11(x_1,…,x_{11})=(x_1-1)^2 +(x_2-2)^2 + … +(x_{11}-11)^2 + 1$,其中$1 \le x_1,…,x_{11} \le 11$,函数的最小值点在(1,2,…,11)处取得，最小值为1。另外还定义了其他几个测试函数为:

• quadratic50:和quadratic11类似,只是变量个数变为50,取值范围变为1-50;
• quadratic100:和quadratic11类似,只是变量个数变为100,取值范围变为1-100;
• quadratic500:和quadratic11类似,只是变量个数变为500,取值范围变为1-500;
• quadratic1000:和quadratic1000类似,只是变量个数变为1000,取值范围变为1-1000;
• Rosenbrock:函数原型为:$Rosenbrock(x_1,x_2)=100(x_1^2-x_2)^2+(1-x_1)^2$,其中$-2.048 \le x_1,x_2 \le 2.048$,这个函数有很多局部极小值点，函数在(-2.048,-2.048)处取得最大值;
• shubert2函数:函数定义为,$shubert2(x_1,x_2)=\prod_{i=1}^{2}(\sum_{j=1}^{5}(jcos((j+1)*x_i+j))$,其中$-10 \le x_1,x_2 \le 10$,函数有760个局部极小值点,全局极小值为-186.731,这里为了将适应度函数变换为正，我们在原函数的基础上加上1000,这样函数的全局极小值点就变为813.269;
• shubert函数，将shubert2函数中的两个变量拓展为n个变量($\prod_{i=1}^{n}$)就可以得到一般的shubert函数了。
      对于每一个优化方法，我们都预定了一个形如xx_config的模块，其中定义了该优化方法的一些常用默认参数，比如ga_config中就定义了一些GA的一些常用优化参数，ga_config.basic_config定义了一些基础参数设置，比如basic_config.generations是一个默认进化代数,basic_config.mutation_rate是默认的变异参数；而ga_config.cross_method则预定义了所有支持的交叉方法,比如cross_method.uniform表示均匀交叉,cross_method.one_point表示单点交叉等;ga_config.mutation_method等也是类似的。有了这些预定义变量，可以免去我们手动输入很多参数取值以及传入方法字符串的麻烦(有时候可能会写错)。
      观察上面的运行结果，我们发现对于quadratic11函数，最终找到的全局极小值为2.2685208668743204,和真实的全局极小值点1已经比较接近了；运行耗时6秒多，似乎有些长，这是因为我们种群数目设为100，进化代数设为200,比较大，而且又是采用二进制20位编码，再加上python脚本语言的运行效率问题，所以稍慢。为了做一个对比,这里我们将目标函数从quadratic11变为Rosenbrock函数，其他参数设置保持不变，得到的结果如下:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  GA costs 1.7245 seconds! -------------------- GA config is: -------------------- population_size:100 lower_bound:[-2.048, -2.048] mutation_rate_exp:1 select_method:proportion code_type:binary global_generations_step:200 generations:200 mutation_method:uniform complex_constraints_method:penalty binary_code_length:20 cross_method:uniform arithmetic_cross_alpha:0.1 func:<function Rosenbrock at 0x7fe5fd538a60> upper_bound:[2.048, 2.048] cross_code:False mutation_rate:0.05 cross_rate_exp:1 complex_constraints_C:1000000.0 cross_rate:0.8 variables_num:2 M:100000000.0 complex_constraints:None none_uniform_mutation_rate:1 tournament_num:2 arithmetic_cross_exp:1 func_type:max -------------------- GA caculation result is: -------------------- global best target generation index/total generations:75/200 global best point:[-2.04776953 -2.04537109] global best target:3901.4655271502425

图2是每代最优值的计算结果:

• cross_rate_exp:cross_rate指数递增的参数取值,即变异率按照$r_t=r_0 \beta^t$,这里$r_t$表示t次迭代的交叉率,$r_0$是初始的交叉率，$\beta$就是这里的cross_rate_exp,默认取值为1,一般设置为一个比1稍大的数字，比如1.0001等;
• mutation_rate_exp:mutation_rate指数递增参数取值,具体含义和cross_rate_exp类似;
• code_type:采用什么样的编码方式,有三种取值:’binary’表示二进制编码(默认),’gray’表示采用格雷编码,’real’表示采用实数编码。其中格雷编码是一种改进的二进制编码，其优点在于进行交叉、变异等操作时，改变了染色体基因的某几个位置，二进制编码对应的实数值可能会发生非常大的变化，而格雷编码一般不会。二进制编码与格雷编码的转换可以参考附录;
• cross_code:这是一个布尔值,表示是否对二进制编码或格雷码采用交叉编码的方式。具体说明参考附录;
• select_method:选择操作方法，有如下的6种取值:

1. ‘proportion’:表示比例选择(轮盘赌法)
2. ‘keep_best’:表示保留最优个体
3. ‘determinate_sampling’:表示确定性采样
4. ‘rssr’:remainder stochastic sampling with replacement的缩写，表示无放回余数随机选择
5. ‘rank’:表示排序选择
6. ‘stochastic_tournament’:表示随机锦标赛法(以上6种选择方式详细说明请参考附录)

• rank_select_probs:仅当select_method取值为’rank’时，该参数才起作用，表示采用排序选择时，适应度从低到高每个个体被选择的概率，默认为None,采用$p_i=\frac{i}{\sum_{j=1}^{n}j},i=1,2,…,n$的方式计算，其中$n$表示种群个数,$p_i$表示第$i$个个体被选择的概率，所有概率之和为1，如果取值不为None,你应该传入一个size为population_size的ndarray,所有元素按照递增排序，数组和为1;
• tournament_num:如果select_method取值为’stochastic_tournament’,该值表示锦标赛竞争者数量;
• cross_method:交叉方法,有如下4种取值:

1. ‘one_point’：表示单点交叉
2. ‘two_point’:表示双点交叉
3. ‘uniform’:表示均匀交叉
4. ‘arithmetic’:表示算术交叉,只有当编码采用实数编码时，才能使用算术交叉

• arithmetic_cross_alpha:算术交叉的系数，算术交叉的公式为:$x_{new1}=\alpha x_1 + (1-\alpha)x_2,x_{new2}=\alpha x_2 + (1-\alpha)x_1$,这里的$\alpha$即表示arithmetic_cross_alpha,其默认值为0.1;
• ‘arithmetic_cross_exp’:算术交叉系数按照指数递增，即$\alpha_t = \alpha r^t$,这里$\alpha_t$表示第t代的算术交叉系数,$\alpha$是初始交叉系数,$r$即是这里的arithmetic_cross_exp,默认取值为1，一般取一个比1稍大的数，比如1.0001,t是进化代数;
• ‘mutation_method’:变异方法，有如下5种取值:

1. simple:即简单变异，随机选择一个染色体上的基因，按照变异概率进行变异
2. uniform:即均匀变异,每个染色体上的每个基因都按照变异概率进行变异
3. boundary:边界变异,每个基因进行变异以后的取值只能去边界值,比如说各以0.5的概率取得其上界和下界，这种变异方式仅适用于实数编码的情况，一般在目标函数的最优点靠近边界时使用
4. none_uniform:非均匀变异，我们不是取均匀分布的随机数去替换原来的基因，而是在原来基因的基础上做一点微小的随机扰动，扰动以后的结果作为新的基因值，具体来说，我们采用的是这样的变异方式:1)if random(0,1) = 0,$x_k^{‘} = x_k + \bigtriangleup (t,U_{max}^{k}-x_k)$;2)if random(0,1) = 1,$x_k{‘} = x_k - \bigtriangleup (t,x_k -U_{min}{k})$ 其中 $\bigtriangleup(t,y)=y(1-r^{(1-t/T)b})$,$r$是0-1均匀分布的一个随机数，$T$是最大进化代数，$b$是一个系统参数，表示随机扰动对于进化代数的依赖长度，默认值为1
5. gaussian:高斯变异,即使用高斯分布去替代均匀分布来进行变异,由高斯分布的特点可以知道，这种变异方式也是在原个体区域附近的某个局部区域进行重点搜索，这里高斯分布的均值$\mu$定义为$\mu = \frac{U_{min}^{k}+U_{max}^{k}}{2}$,标准差$\sigma=\frac{U_{max}^{k}-U_{min}^{k}}{6}$

• none_uniform_mutation_rate:即均匀分布none_uniform中定义的系统参数$b$;

• complex_constraints:复杂约束,默认值为None,即没有复杂约束,只有简单的边界约束,如果有复杂约束，其取值应该是$[func_1,func_2,…,func_n]$,
  其中$func_i$表示第$i$个复杂约束函数名，比如对于一个复杂约束函数$func_1:x_1^2+x_2^2 < 3$,其复杂约束函数应该这样定义:

  1 2 3 4

  def func1(x): x1 = x[0] x2 = x[1] return x1**2 + x2**2 - 3

• complex_constraints_method:复杂约束求解的方法,默认是penalty即惩罚函数法，暂时不支持其他的求解方式;

• complex_constraints_C:采用penalty求解复杂约束的系数$C$,比如对于某一个约束$x_1^2+x_2^2 < 3$,GA在求解过程中，违反了该约束,即解满足$x_1^2+x_2^2 \ge 3$,那么我们对目标函数增加一个惩罚项: $C(x_1^2+x_2^2-3)$,$C$一般取一个很大的正数，默认值为$10^6$。
      GA类的参数很多可以调节，所以相比之下使用起来更加麻烦，特别是对于复杂函数的寻优，默认参数未必是最好的，可能需要你根据目标函数的特点自行尝试，选择最优的参数组合。
  

  3. PSO 使用

  
      PSO算法的原理可以参考我之前的博客C语言实现粒子群算法(PSO)一和C语言实现粒子群算法（PSO）二,这里不再赘述。还是先看一个实例代码:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

  from time import time from sopt.util.functions import * from sopt.util.pso_config import * from sopt.PSO.PSO import PSO from sopt.util.constraints import * class TestPSO: def __init__(self): self.func = quadratic11 self.func_type = quadratic11_func_type self.variables_num = quadratic11_variables_num self.lower_bound = quadratic11_lower_bound self.upper_bound = quadratic11_upper_bound self.c1 = basic_config.c1 self.c2 = basic_config.c2 self.generations = 200 self.population_size = 100 self.vmax = 1 self.vmin = -1 self.w = 1 self.w_start = 0.9 self.w_end = 0.4 self.w_method = pso_w_method.linear_decrease #self.complex_constraints = [constraints1,constraints2,constraints3] self.complex_constraints = None self.complex_constraints_method = complex_constraints_method.loop self.PSO = PSO(**self.__dict__) def test(self): start_time = time() self.PSO.run() print("PSO costs %.4f seconds!" %(time()-start_time)) self.PSO.save_plot() self.PSO.show_result() if __name__ == '__main__': TestPSO().test()

运行结果为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

PSO costs 1.1731 seconds!
-------------------- PSO config is: --------------------
complex_constraints_method:loop
c1:1.49445
lower_bound:[1 1 1 1 1 1 1 1 1 1 1]
w_end:0.4
w_method:linear_decrease
complex_constraints:None
func:<function quadratic11 at 0x7f1ddb81a510>
upper_bound:[11 11 11 11 11 11 11 11 11 11 11]
generations:200
func_type:min
w:1
c2:1.49445
w_start:0.9
population_size:100
vmin:-1
vmax:1
variables_num:11
-------------------- PSO calculation result is: --------------------
global best generation index/total generations: 198/200
global best point: [ 1.          1.99999999  2.99999999  4.          5.          6.
  7.00000001  7.99999999  9.00000001 10.00000001 11.        ]
global best target: 1.0

• variables_num:变量个数(必填);
• lower_bound:一个int或者float的数字，或者是长度为variables_num的ndarray,表示每个变量的下界,如果是一个数字的话，我们认为所有的下界都是一样的(必填);
• upper_bound:一个int或者float的数字,或者是长度为variables_num的ndarray,表示每个变量的上界,如果是一个数字的话，我们认为所有的上界都是一样的(必填);
• func:目标函数名(必填);
• func_type:函数优化类型,求最小值取值为’min’,求最大值取值为’max’,默认是’min’;
• c1:PSO 参数c1,默认值为1.49445;
• c2:PSO 参数c2,默认值为1.49445;
• generations:进化代数,默认值为100;
• population_size:种群数量,默认为50;
• vmax:粒子最大速度,默认值为1;
• vmin:粒子最小速度,默认值为-1;
• w:粒子惯性权重,默认为1;
• w_start:如果不是使用恒定的惯性权重话,比如使用权重递减策略,w_start表示初始权重;
• w_end:相应的,w_end表示末尾权重;
• w_method:权重递减的方式,有如下5种取值:

1. ‘constant’:权重恒定
2. ‘linear_decrease’:线性递减,即$w_t = w_{end} + (w_{start} - w_{end})\frac{(T-t)}{T}$,其中$T$表示最大进化代数,$w_t$表示第$t$代权重
3. ‘square1_decrease’:第一种平方递减,即:$w_t = w_{start} - (w_{start}-w_{end})(\frac{t}{T})^2$
4. ‘square2_decrease’:第二种平方递减,即：$w_t = w_{start} - (w_{start}-w_{end})(\frac{2t}{T}-(\frac{t}{T})^2)$
5. ‘exp_decrease’:指数递减,即:$w_t = w_{end}(\frac{w_{start}}{w_{end}})^{\frac{1}{1+\frac{10t}{T}}}$

• complex_constraints:复杂约束，默认为None,具体含义参考GA类的complex_constraints
• complex_constraints_method:求解复杂约束的方法，默认为’loop’,即如果解不满足复杂约束，则再次随机产生解，直到满足约束,暂时不支持其他的求解方式。
  

  4. SA 使用

  
      SA,即模拟退火算法，是基于概率的一种寻优方法，具体原理可以参考我的博客模拟退火算法（SA）求解TSP 问题（C语言实现）。sopt中SA的使用实例如下:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

  from time import time from sopt.util.functions import * from sopt.Optimizers.SA import SA from sopt.util.sa_config import * from sopt.util.constraints import * class TestSA: def __init__(self): self.func = Rosenbrock self.func_type = Rosenbrock_func_type self.variables_num = Rosenbrock_variables_num self.lower_bound = Rosenbrock_lower_bound self.upper_bound = Rosenbrock_upper_bound self.T_start = 100 self.T_end = 1e-6 self.q = 0.9 self.L = 100 self.init_pos = None #self.complex_constraints = [constraints1,constraints2,constraints3] self.complex_constraints_method = complex_constraints_method.loop self.SA = SA(**self.__dict__) def test(self): start_time = time() self.SA.run() print("SA costs %.4f seconds!" %(time()-start_time)) self.SA.save_plot() self.SA.show_result() if __name__ == '__main__': TestSA().test()

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

SA costs 0.2039 seconds!
-------------------- SA config is: --------------------
func_type:max
complex_constraints:None
q:0.9
complex_constraints_method:loop
T_start:100
steps:17500
T_end:1e-06
L:100
func:<function Rosenbrock at 0x7f8261799048>
variables_num:2
lower_bound:[-2.048 -2.048]
init_pos:[-2.03887265 -2.02503927]
upper_bound:[2.048 2.048]
-------------------- SA calculation result is: --------------------
global best generation index/total generations:2126/17500
global best point: [-2.03887265 -2.02503927]
global best target: 3830.997799328349

• variables_num:变量个数(必填);
• lower_bound:一个int或者float的数字，或者是长度为variables_num的ndarray,表示每个变量的下界,如果是一个数字的话，我们认为所有的下界都是一样的(必填);
• upper_bound:一个int或者float的数字,或者是长度为variables_num的ndarray,表示每个变量的上界,如果是一个数字的话，我们认为所有的上界都是一样的(必填);
• func:目标函数名(必填);
• func_type:函数优化类型,求最小值取值为’min’,求最大值取值为’max’,默认是’min’;
• T_start:初始温度,默认值为100;
• T_end:末尾温度,默认值为$10^{-6}$;
• q:退火系数,默认值为0.9,一般取一个在[0.9,1)之间的数字;
• L:每个温度时的迭代次数，即链长,默认值为100;
• init_pos:初始解的取值，默认值为None,此时初始解是随机生成的,或者你也可以指定一个用ndarray表示的初始解;
• complex_constraints:复杂约束，默认为None,表示没有约束，具体定义同GA 的 complex_constraints;
• complex_constraints_method:求解复杂约束的方法，默认为’loop’,即如果解不满足复杂约束，则再次随机产生解，直到满足约束,暂时不支持其他的求解方式。
  

  5. Random Walk 使用

  
      Random Walk 即随机游走算法，是一种全局随机搜索算法，具体原理可以参考我的博客介绍一个全局最优化的方法：随机游走算法(Random Walk)。sopt中Random Walk的使用实例如下:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

  from time import time from sopt.util.functions import * from sopt.util.constraints import * from sopt.util.random_walk_config import * from sopt.Optimizers.RandomWalk import RandomWalk class TestRandomWalk: def __init__(self): self.func = quadratic50 self.func_type = quadratic50_func_type self.variables_num = quadratic50_variables_num self.lower_bound = quadratic50_lower_bound self.upper_bound = quadratic50_upper_bound self.generations = 100 self.init_step = 10 self.eps = 1e-4 self.vectors_num = 10 self.init_pos = None # self.complex_constraints = [constraints1,constraints2,constraints3] self.complex_constraints = None self.complex_constraints_method = complex_constraints_method.loop self.RandomWalk = RandomWalk(**self.__dict__) def test(self): start_time = time() self.RandomWalk.random_walk() print("random walk costs %.4f seconds!" %(time() - start_time)) self.RandomWalk.save_plot() self.RandomWalk.show_result() if __name__ == '__main__': TestRandomWalk().test()

运行结果为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Finish 1 random walk!
Finish 2 random walk!
Finish 3 random walk!
Finish 4 random walk!
Finish 5 random walk!
Finish 6 random walk!
Finish 7 random walk!
Finish 8 random walk!
Finish 9 random walk!
Finish 10 random walk!
Finish 11 random walk!
Finish 12 random walk!
Finish 13 random walk!
Finish 14 random walk!
Finish 15 random walk!
Finish 16 random walk!
Finish 17 random walk!
random walk costs 1.0647 seconds!
-------------------- random walk config is: --------------------
init_step:10
eps:0.0001
generations_nums:9042
lower_bound:[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1]
complex_constraints_method:loop
walk_nums:17
complex_constraints:None
vectors_num:10
upper_bound:[50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50
 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50
 50 50]
variables_num:50
func:<function quadratic50 at 0x7f51555a1840>
generations:100
func_type:min
-------------------- random walk caculation result is: --------------------
global best generation index/total generations:8942/9042
global best point is: [ 1.00004803  1.99999419  3.00000569  3.99998558  5.00002455  5.99999255
  6.99992476  7.99992864  9.00000401  9.99994717 10.99998155 12.00002429
 13.0000035  13.99998567 15.00000421 16.00001454 16.99997252 17.99998041
 19.00002491 20.00003141 21.00004182 21.99998565 22.99997668 23.99999821
 24.99995881 25.99999359 27.00000443 28.00005117 28.99998132 30.00004136
 31.00002021 32.00000616 33.00000678 34.00005423 35.00001799 36.00000051
 37.00002749 38.00000203 39.00007087 39.9999964  41.00004432 42.0000158
 42.99992991 43.99995352 44.99997267 46.00003533 46.9999834  47.99996778
 49.00002904 50.        ]
global best target is: 1.0000000528527013

• variables_num:变量个数(必填);
• lower_bound:一个int或者float的数字，或者是长度为variables_num的ndarray,表示每个变量的下界,如果是一个数字的话，我们认为所有的下界都是一样的(必填);
• upper_bound:一个int或者float的数字,或者是长度为variables_num的ndarray,表示每个变量的上界,如果是一个数字的话，我们认为所有的上界都是一样的(必填);
• func:目标函数名(必填);
• func_type:函数优化类型,求最小值取值为’min’,求最大值取值为’max’,默认是’min’;
• generations:每个step的最大迭代次数,默认是100;
• init_step:初始步长(step)，默认值为10.0;
• eps:终止迭代的步长,默认为$10^{-4}$;
• vectors_num:使用 improved_random_walk时随机产生向量的个数,默认为10;
• init_pos:初始解的取值，默认值为None,此时初始解是随机生成的,或者你也可以指定一个用ndarray表示的初始解;
• complex_constraints:复杂约束，默认为None,表示没有约束，具体定义同GA 的 complex_constraints;
• complex_constraints_method:求解复杂约束的方法，默认为’loop’,即如果解不满足复杂约束，则再次随机产生解，直到满足约束,暂时不支持其他的求解方式。
  RandomWalk 除了提供基本的random_walk函数之外，还提供了一个更加强大的improved_random_walk函数，后者的全局寻优能力要更强。
  

  6. 求解带复杂约束的目标函数

  
      上面所述的各种优化方法求解的都是变量仅有简单边界约束(形如$a \le x_i \le b$),下面介绍如何使用各种优化方法求解带有复杂约束条件的目标函数。其实，求解方法也非常简单，以GA为例，下面的例子即对Rosenbrock函数求解了带有三个复杂约束条件的最优值:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

  from time import time from sopt.GA.GA import GA from sopt.util.functions import * from sopt.util.ga_config import * from sopt.util.constraints import * class TestGA: def __init__(self): self.func = Rosenbrock self.func_type = Rosenbrock_func_type self.variables_num = Rosenbrock_variables_num self.lower_bound = Rosenbrock_lower_bound self.upper_bound = Rosenbrock_upper_bound self.cross_rate = 0.8 self.mutation_rate = 0.1 self.generations = 300 self.population_size = 200 self.binary_code_length = 20 self.cross_rate_exp = 1 self.mutation_rate_exp = 1 self.code_type = code_type.real self.cross_code = False self.select_method = select_method.proportion self.rank_select_probs = None self.tournament_num = 2 self.cross_method = cross_method.uniform self.arithmetic_cross_alpha = 0.1 self.arithmetic_cross_exp = 1 self.mutation_method = mutation_method.uniform self.none_uniform_mutation_rate = 1 self.complex_constraints = [constraints1,constraints2,constraints3] self.complex_constraints_method = complex_constraints_method.penalty self.complex_constraints_C = 1e8 self.M = 1e8 self.GA = GA(**self.__dict__) def test(self): start_time = time() self.GA.run() print("GA costs %.4f seconds!" % (time()-start_time)) self.GA.save_plot() self.GA.show_result() if __name__ == '__main__': TestGA().test()

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

GA costs 1.9957 seconds!
-------------------- GA config is: --------------------
lower_bound:[-2.048, -2.048]
cross_code:False
complex_constraints_method:penalty
mutation_method:uniform
mutation_rate:0.1
mutation_rate_exp:1
cross_rate:0.8
upper_bound:[2.048, 2.048]
arithmetic_cross_exp:1
variables_num:2
generations:300
tournament_num:2
select_method:proportion
func_type:max
complex_constraints_C:100000000.0
cross_method:uniform
complex_constraints:[<function constraints1 at 0x7f5efe2e8d08>, <function constraints2 at 0x7f5efe2e8d90>, <function constraints3 at 0x7f5efe2e8e18>]
func:<function Rosenbrock at 0x7f5efe2e87b8>
none_uniform_mutation_rate:1
cross_rate_exp:1
code_type:real
M:100000000.0
binary_code_length:20
global_generations_step:300
population_size:200
arithmetic_cross_alpha:0.1
-------------------- GA caculation result is: --------------------
global best target generation index/total generations:226/300
global best point:[ 1.7182846  -1.74504313]
global best target:2207.2089435117955

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def constraints1(x):
    x1 = x[0]
    x2 = x[1]
    return x1**2 + x2**2 -3

def constraints2(x):
    x1 = x[0]
    x2 = x[1]
    return x1+x2

def constraints3(x):
    x1 = x[0]
    x2 = x[1]
    return -2 -x1 -x2

其实观察可以发现，上面的代码和原始的GA实例代码唯一的区别，就是其增加了self.complex_constraints = [constraints1,constraints2,constraints3]这样一句，对于其他的优化方法，其都定义了complex_constraints和complex_constraints_method这两个属性，只要传入相应的约束条件函数列表以及求解约束条件的方法就可以求解带复杂约束的目标函数了。比如我们再用Random Walk求解和上面一样的带三个约束的Rosenbrock函数，代码及运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from time import time
from sopt.util.functions import *
from sopt.util.constraints import *
from sopt.util.random_walk_config import *
from sopt.Optimizers.RandomWalk import RandomWalk

class TestRandomWalk:
    def __init__(self):
        self.func = Rosenbrock
        self.func_type = Rosenbrock_func_type
        self.variables_num = Rosenbrock_variables_num
        self.lower_bound = Rosenbrock_lower_bound
        self.upper_bound = Rosenbrock_upper_bound
        self.generations = 100
        self.init_step = 10
        self.eps = 1e-4
        self.vectors_num = 10
        self.init_pos = None
        self.complex_constraints = [constraints1,constraints2,constraints3]
        self.complex_constraints_method = complex_constraints_method.loop
        self.RandomWalk = RandomWalk(**self.__dict__)

    def test(self):
        start_time = time()
        self.RandomWalk.random_walk()
        print("random walk costs %.4f seconds!" %(time() - start_time))
        self.RandomWalk.save_plot()
        self.RandomWalk.show_result()


if __name__ == '__main__':
    TestRandomWalk().test()

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Finish 1 random walk!
Finish 2 random walk!
Finish 3 random walk!
Finish 4 random walk!
Finish 5 random walk!
Finish 6 random walk!
Finish 7 random walk!
Finish 8 random walk!
Finish 9 random walk!
Finish 10 random walk!
Finish 11 random walk!
Finish 12 random walk!
Finish 13 random walk!
Finish 14 random walk!
Finish 15 random walk!
Finish 16 random walk!
Finish 17 random walk!
random walk costs 0.1543 seconds!
-------------------- random walk config is: --------------------
eps:0.0001
func_type:max
lower_bound:[-2.048 -2.048]
upper_bound:[2.048 2.048]
init_step:10
vectors_num:10
func:<function Rosenbrock at 0x7f547fc952f0>
variables_num:2
walk_nums:17
complex_constraints_method:loop
generations:100
generations_nums:2191
complex_constraints:[<function constraints1 at 0x7f547fc95bf8>, <function constraints2 at 0x7f547fc95c80>, <function constraints3 at 0x7f547fc95d08>]
-------------------- random walk caculation result is: --------------------
global best generation index/total generations:2091/2191
global best point is: [-2.41416736  0.41430367]
global best target is: 2942.6882849234585

7. 基于梯度的系列优化方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from time import time
from sopt.util.gradients_config import *
from sopt.util.functions import *
from sopt.Optimizers.Gradients import GradientDescent


class TestGradientDescent:
    def __init__(self):
        self.func = quadratic50
        self.func_type = quadratic50_func_type
        self.variables_num = quadratic50_variables_num
        self.init_variables = None
        self.lr = 1e-3
        self.epochs = 5000
        self.GradientDescent = GradientDescent(**self.__dict__)

    def test(self):
        start_time = time()
        self.GradientDescent.run()
        print("Gradient Descent costs %.4f seconds!" %(time()-start_time))
        self.GradientDescent.save_plot()
        self.GradientDescent.show_result()



if __name__ == '__main__':
    TestGradientDescent().test()

运行结果为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Gradient Descent costs 14.3231 seconds!
-------------------- Gradient Descent config is: --------------------
func_type:min
variables_num:50
func:<function quadratic50 at 0x7f74e737b620>
epochs:5000
lr:0.001
-------------------- Gradient Descent caculation result is: --------------------
global best epoch/total epochs:4999/5000
global best point: [ 0.9999524   1.99991045  2.99984898  3.9998496   4.99977767  5.9997246
  6.99967516  7.99964102  8.99958143  9.99951782 10.99947879 11.99944665
 12.99942492 13.99935192 14.99932708 15.99925856 16.99923686 17.99921689
 18.99911527 19.9991255  20.99908968 21.99899699 22.99899622 23.99887832
 24.99883597 25.99885616 26.99881394 27.99869772 28.99869349 29.9986766
 30.99861142 31.99851987 32.998556   33.99849351 34.99845985 35.99836731
 36.99832444 37.99831792 38.99821067 39.99816567 40.99814951 41.99808199
 42.99808161 43.99806655 44.99801207 45.99794449 46.99788003 47.99785468
 48.99780825 49.99771656]
global best target: 1.0000867498727912

1. GradientDescent类:

• lr:学习率,默认是$10^{-3}$;
• epochs:迭代次数，默认是100；

2. Momentum类:

• lr:学习率,默认是$10^{-3}$;
• beta:Momentum的$\beta$参数，默认是0.9;
• epochs:迭代次数，默认是100；

3. AdaGrad类:

• lr:学习率,默认是$10^{-3}$;
• eps:极小的一个正数(防止分母为0),默认为$10^{-8}$;
• epochs:迭代次数，默认是100；

4. RMSProp类:

• lr:学习率,默认是$10^{-3}$;
• beta:RMSProp的$\beta$参数，默认是0.9;
• eps:极小的一个正数(防止分母为0),默认为$10^{-8}$;
• epochs:迭代次数，默认是100；

5. Adam类:

• lr:学习率,默认是$10^{-3}$;
• beta1:Adam的$\beta_1$参数，默认是0.5;
• beta2:Adam的$\beta_2$参数，默认是0.9;
• eps:极小的一个正数(防止分母为0),默认为$10^{-8}$;
• epochs:迭代次数，默认是100；
  这里额外说一句,Adam原文作者给出的最优超参数为$\beta_1 = 0.9,\beta_2 = 0.999$,但是我在实际调试过程中发现,$\beta_1 = 0.5,\beta_2 = 0.9$才能达到比较好的效果，具体原因目前不是很清楚。如果想要学习各个优化函数类的具体用法，还可以使用from sopt.test import *导入预定义的示例测试，来运行观察结果。比如下面的代码就运行了PSO的一个示例测试:

  1 2	from sopt.test import test_PSO test_PSO.TestPSO().test()

结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

PSO costs 3.4806 seconds!
-------------------- PSO config is: --------------------
lower_bound:[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1]
generations:200
vmin:-1
func:<function quadratic50 at 0x7fd3bf37d8c8>
w_method:linear_decrease
func_type:min
population_size:100
w_start:0.9
complex_constraints_method:loop
vmax:1
c2:1.49445
upper_bound:[50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50
 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50]
variables_num:50
c1:1.49445
w:1
complex_constraints:None
w_end:0.4
-------------------- PSO calculation result is: --------------------
global best generation index/total generations: 199/200
global best point: [  1.           1.           2.94484328   4.13875216   5.00293498
   6.13124759   6.99713025   7.92116383   8.87648843  10.02066994
  11.0758768   12.02240279  13.01125368  13.98010373  14.98063168
  15.97776149  17.11878537  18.00246112  18.14780887  20.00637617
  21.00223704  22.00689373  23.14823218  24.0002456   24.98672157
  25.99141686  27.02112321  28.01540506  29.05403155  30.07304888
  31.00414822  32.00982867  32.99444884  33.9114213   34.96631157
  36.22871824  37.0015616   37.98907918  39.01245751  40.1371835
  41.0182043   42.07768102  42.87178292  43.93687997  45.05786395
  46.03778693  47.07913415  50.          48.9964866   50.        ]
global best target: 6.95906097685

附录

To do …

1. GA的并行化计算
2. 小生境GA
3. GA,PSO等求解离散函数最优解
4. GA,PSO等实际应用举例
5. 其他的一些最优化方法,比如牛顿法，拟牛顿法等
6. 其他

    最近程序员圈传的很火的一件事就是:Github马上要被微(巨)软(硬)收购了！据传好像是50亿美金，刷知乎的时候看到好像最近有不少用户从Github跑到Gitlab了?作为一个小白，其实我对这件事情并没有太大的看法。不管微软要不要收购Github,该用还不是照样用?总不会要边收费???今天打开Github首页的时候，它就推送了一条新闻:Microsoft is acquiring GitHub! Read our blog and Satya Nadella’s post to learn more。所以我就点进去看了一下，原来是Github的创始人兼CEO defunkt的公开信，下面就让我们看看他是怎么说的吧(以下内容翻译自:https://blog.github.com/2018-06-04-github-microsoft/)。

    条件GAN(Conditional Generative Adversarial Nets),原文地址为CGAN。

Abstract

1. Introduction

2. Related Work

2.1 图像标签的多模态学习

3. Conditional Adersarial Nets(条件对抗网络)

3.1 Generative Adervasarial Nets

3.2 Conditional Adersarial Nets

4. Experimental Results

4.1 Unimodal(单一模式)

4.2 Multimodal(多模态)

5. Feature Work

References

3.1 Image class

1
2
3
4
5
6
7

>>> from PIL import Image
>>> Image.open("dog.jpg","r")
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=296x299 at 0x7F62BDB5B0F0
>
>>> im = Image.open("dog.jpg","r")
>>> print(im.size,im.format,im.mode)
(296, 299) JPEG RGB

1

>>> im.save("dog.png",'png')

1
2

>>> im.thumbnail((50,50),resample=Image.BICUBIC)
>>> im.show()

1
2
3
4
5

>>> im = Image.open("dog.jpg","r")
>>> box = (100,100,200,200)
>>> region = im.crop(box)
>>> region.show()
im.crop()

1
2

>>> im_rotate_180 = im.transpose(Image.ROTATE_180)
>>> im_rotate_180.show()

1
2

>>> im.paste(region,(100,100),None)
>>> im.show()

1
2
3
4

>>> r,g,b = im.split()
>>> r.show()
>>> g.show()
>>> b.show()

1
2

>>> im_merge = Image.merge("RGB",[b,r,g])
>>> im_merge.show()

1
2
3
4
5
6

>>> im_resize = im.resize((200,200))
>>> im_resize
<PIL.Image.Image image mode=RGB size=200x200 at 0x7F62B9E23470>
>>> im_resize.show()
>>> im_resize_box = im.resize((100,100),box = (0,0,50,50))
>>> im_resize_box.show()

1
2
3
4
5
6
7
8

>>> im_L = im.convert("L")
>>> im_L.show()
>>> im_rgb = im_L.convert("RGB")
>>> im_rgb.show()
>>> im_L.mode
'L'
>>> im_rgb.mode
'RGB'

1
2
3
4
5
6
7
8

>>> im = Image.open("dog.jpg","r")
>>> from PIL import ImageFilter
>>> im_blur = im.filter(ImageFilter.BLUR)
>>> im_blur.show()
>>> im_find_edges = im.filter(ImageFilter.FIND_EDGES)
>>> im_find_edges.show()
>>> im_find_edges.save("find_edges.jpg")
>>> im_blur.save("blur.jpg")

• point(lut,mode)(对图像像素操作)

  1 2 3

  >>> im_point = im.point(lambda x:x*1.5) >>> im_point.show() >>> im_point.save("im_point.jpg")

point方法可以对图像进行单个像素的操作，上面的代码对point方法传入了一个匿名函数,表示将图像的每个像素点大小都乘以1.5,mode是返回的图像的模式，默认是和原来图像的mode是一样的。图2是原来的dog.jpg和point操作之后的im_point.jpg之间的对比。

1
2
3
4
5
6
7
8
9
10
11

>>> source = im.split()
>>> R,G,B = 0,1,2
>>> mask = source[R].point(lambda x: x<100 and 255) 
>>> # x<100,return 255,otherwise return 0
>>> out_G = source[G].point(lambda x:x*0.7)
>>> # 将out_G粘贴回来，但是只保留'R'通道像素值<100的部分
>>> source[G].paste(out_G,None,mask)
>>> # 合并成新的图像
>>> im_new = Image.merge(im.mode,source)
>>> im_new.show()
>>> im.show()

• ImageEnhance()(图像增强)

  1 2 3 4 5 6 7 8

  >>> from PIL import ImageEnhance >>> brightness = ImageEnhanBce.Brightness(im) >>> im_brightness = brightness.enhance(1.5) >>> im_brightness.show() >>> im_contrast = ImageEnhance.Contrast(im) >>> im_contrast.enhance(1.5) <PIL.Image.Image image mode=RGB size=296x299 at 0x7F62AE271AC8> >>> im_contrast.enhance(1.5).show()

ImageEnhance是PIL下的一个子类，主要用于图像增强，比如增加亮度(Brightness),增加对比度(Contrast)等。上面的代码将原来图像的亮度增加50%,将对比度也增加了50%。

• ImageSequence()(处理图像序列)
  下面的代码可以遍历gif图像中的所有帧，并分别保存为图像

  1 2 3 4 5 6 7 8

  >>> from PIL import ImageSequence >>> from PIL import Image >>> gif = Image.open("pipixia.gif") >>> for i,frame in enumerate(ImageSequence.Iterator(gif),1): ... if frame.mode == 'JPEG': ... frame.save("%d.jpg" %i) ... else: ... frame.save("%d.png" % i)

除了上面使用迭代器的方式以外，还可以一帧一帧读取gif,比如下面的代码:

1
2
3
4
5
6
7
8
9

>>> index = 0
>>> while 1:
...     try:
...         gif.seek(index)
...         gif.save("%d.%s" %(index,'jpg' if gif.mode == 'JPEG' else 'png'))
...         index += 1
...     except EOFError:
...         print("Reach the end of gif sequence!")
...         break

上面的代码在读取到gif的最后一帧之后，会throw 一个 EOFError,所以我们只要捕获这个异常就可以了。

    最近租的房子快到期了，哎，因为去年是第一次找房子租，结果遇到了一个东北黑中介，押一付三，房子有啥问题，灯坏了，下水道堵了，原来签合同的时候说的客气，说是马上就会上门解决，结果实际上我每次找他，都是各种推脱，最后不了了之。全部是我自己想办法解决的。现在又打电话催着我要搬走，押金也不打算退给我了。真的是rlgl。我反对地域黑，但是以后东北的中介一生黑。(再次声明，不是地域黑，我也有认识的人很好的东北的朋友。)今天我又看到了有钱可以为所欲为的经典gif,所以我心血来潮想做一个自己的东北黑中介版的为所欲为gif。本来我想找一个没有文字的gif,然后找一个软件添加文字，然后合成gif的。结果在网上搜索了一下，没有找到合适的原版gif,只找到了一个有文字的gif。到是有软件可以手动添加文字合成gif的，但是如果要首先把原来的文字去除，然后再一点点添加，手动要做大量的工作，很是麻烦。我再尝试了半个小时还没弄好就放弃了(但是我想应该有比较简便的方法，只是我懒得再自己去找了)。最后我想既然作为一个程序员，能不能通过代码去实现这个功能呢？当然可以啦。我最熟悉的是python,自然优先考虑上python了。之前接触过PIL这个库，我记得它有给图片添加文字的功能，而且最近不是才刚刚看了moviepy这个库，它可以很容易合成gif,把这两个结合到一起不就很容易实现我想要的目标了吗？一不做二不休，开搞!

1. 处理gif以及基本思路

    我找到的原始的gif如下图1所示:

1

ffmpeg -i 为所欲为.gif %d.jpg

1
2
3
4

from PIL import Image,ImageSequence
gif = Image.open("为所欲为.gif")
for i,frame in enumerate(ImageSequence.Iterator(gif),1):
    frame.save("%d.jpg" % i)

2. 实现代码以及简要解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# -*- coding:utf-8 -*-
import matplotlib.pyplot as plt 
from PIL import Image,ImageDraw,ImageFont
from scipy.misc import imread,imsave,imresize
import numpy as np 
import os
from glob import glob
from moviepy.editor import ImageSequenceClip


# 消除文字的图片序号
modify_img_index = list(range(11,14))+list(range(27,37)) + list(range(44,61)) + list(range(62,81)) \
                    + list(range(82,94)) + list(range(97,106)) + list(range(112,132)) + list(range(146,168))
text_info = [('好啊',(120,140))]*(14-11) + \
            [('就算你今天找人来抗议',(40,140))]*(37-27)  + \
            [('就算你的理由再完美',(50,140))] *(61-44)  + \
            [('我想不退钱就不退钱',(50,140))] *(81-62) + \
            [('毕竟我是东北黑中介',(50,140))] *(94-82) + \
            [('东北黑中介了不起啊',(50,140))] *(106-97) + \
            [('sorry,东北黑中介真的可以为所欲为',(5,140))]*(132-112) + \
            [('以后让他天天闹',(60,140))]*(158-146) + \
            [('天天闹',(110,140))]*(169-158)
index_to_text = dict(zip(modify_img_index,text_info))
# 保存图片文件夹
save_dir = "output"
if not os.path.exists(save_dir):
    os.mkdir(save_dir)
new_color = np.array([50,50,50]) # 消除文字之后的颜色
fontsize = 18
fontcolor = (0,255,255)
fps = 10
resize_scale = 1.5 # 新图的宽和高是原来的多少倍
# 消除文字的x,y边界坐标
y_begin = 10
y_end = 280
x_begin = 140
x_end = 160
# 全部文件列表(无序)
img_names = glob("*.jpg")
#print(img_names)


def modify():
    # 遍历每一个图像
    for img_name in img_names:
        img = imread(img_name)
        h,w = img.shape[0],img.shape[1]
        #plt.imshow(img)
        img_new = np.copy(img)
        index = int(img_name.split(".")[0])
        # 如果图片有文字，需要修改
        if index in modify_img_index:
            # 消除文字
            img_new[x_begin:x_end,y_begin:y_end] = new_color
            text,pos = index_to_text[index]
            img_new = drawtext(Image.fromarray(img_new),text,pos,fontsize,fontcolor)
            #保存新的图片
            # imsave(os.path.join(save_dir,img_name),img_new)
            if resize_scale != 1:
                # resize
                img_new = img_new.resize((int(w*resize_scale),int(h*resize_scale)))
                img_new.save(os.path.join(save_dir,img_name))
            print("Modify and save %s!" % img_name)
        else:
            # 没有文字，不需要修改，直接保存原来的图片
            if resize_scale != 1:
                img = imresize(img,resize_scale)
                imsave(os.path.join(save_dir,img_name),img)
            print("Save %s!" % img_name)


def drawtext(img,text,pos,fontsize,fontcolor):
    '''
    draw text for img
    @param img:image to draw text
    @param text:text to draw
    @param pos:where to draw the text((x,y))
    @param fontsize: font size
    @param fontcolor: font color
    '''
    font = ImageFont.truetype("simsun.ttc",fontsize)
    draw = ImageDraw.Draw(img)
    draw.text(pos,text,fontcolor,font = font)
    # plt.imshow(img)
    # plt.show()
    return img 

def test_drawtext():
    img_name = "4.jpg"
    img = Image.open(img_name)
    #text = "好啊"
    text = "东北黑中介了不起啊"
    pos = (40,140)
    fontsize = 20
    fontcolor = (0,255,255)
    drawtext(img,text,pos,fontsize,fontcolor)

# 利用图像序列生成gif
def generate_gif(img_names,save_path,fps = 10):
    # img_names:list of image names
    clip = ImageSequenceClip(img_names,fps = fps)
    clip.write_gif(save_path)
    print("Write %s successfully!" % save_path)

# 主函数
def main():
    modify()
    save_gif_path = os.path.join(save_dir,"东北黑中介.gif")
    img_names = sorted(glob(os.path.join(save_dir,"*.jpg")),key = lambda x: int(x.split(".")[0].split("/")[1]))
    generate_gif(img_names,save_gif_path,fps)

#test_drawtext()
if __name__ == '__main__':
    main()

3. 小结

    本文主要利用python的PIL库(用于处理图像,添加文字等)和moviepy(用于生成gif)自动生成了gif并添加了文字。但是还有一些问题，比如文字自动定位并识别没有解决。这些问题留到后面介绍OCR技术的时候再和大家介绍。如果只是简单地尝试合成gif,大家不妨自己动手试一试。

    之前用阿里云弹性web托管采用wordpress搭建的个人博客，经过我使用一段时间之后发现存在很多问题:

• 网站的响应速度非常慢，估计打开主页需要3-4s的时间，我经过搜索发现很多人都有这样的问题，所以应该不是wordpress的锅，而是阿里云弹性web托管的问题，毕竟我买的时候一年只要几百块，而且还是最便宜的经济版(内存128M+2G网页空间+4G流量+1G数据库)。其实我后来才知道弹性web托管是一个啥玩意
  ，和虚拟机差不多，性能非常有限。可惜我当时不知道啊，否则应该买云虚拟主机独享版的，虽然贵一点，但是应该会流畅很多。
• 我最开始买的是经济版，因为访问速度慢的原因，我昨天打算把它升级成高级版(256M内存+4G网页空间+2G数据库)。我花了不到20块钱买了试用升级两个月。但是最坑爹的事情发生了，我在升级了之后，原来
  的网站打开速度并没有提升多少(至少我没感觉到)，而且出现了一系列的问题，最后我连后台都进不去了，
  一直提示我500内部错误。我搜索了半天也没找到解决办法。而且我用filezilla也一直连不上ftp(我确认账号和密码都是对的，升级之前一直可以登录)，这样我根本没法检查wordpress到底哪里出现问题
  了。于是我陷入了只能浏览我的博客，但是却无法登录后台的尴尬境地。
• 尝试了半天我也没有解决这个问题。最后想了一下，反正我的web弹性托管再过一个多月也就到期了，算
  了，干脆不续费了。重新找个其他的办法搭博客吧。这里额外说一句，之前一直是在博客园写博客的，其实
  还是很不错的，我一直是用的markdown写的，感觉博客园的markdown解析速度挺快，而且网页打开也很快。虽然如此，但是我还是想搭一个自己的博客(毕竟可以自己的地盘自己做主嘛)。想到了之前好像看过
  可以用github免费搭建静态网页的博客。于是我就查资料开工了。事实证明，用github搭建博客稍微有点麻烦，但是对于一般的程序员应该花几个小时就搞好了,我自己大概花了不到三个小时吧。

1. 搭建过程

    因为网上已经有很多介绍怎么用github搭建博客的教程了，其中不乏一些非常详细优秀的教程，所以这里我就不从头详细描述一遍了。只是简单走下流程，贴一些有用的资料和遇到的坑。(注:我的本机系统是Ubuntu 16.04,好像windows系统搭建过程略有差别，如果你是windows系统，请搜索其他安装教程)。

    1.1 我参考的资料。

• 在github上搭建hexo个人博客（Linux-Ubuntu）
• 我是如何利用Github Pages搭建起我的博客，细数一路的坑
• hexo推荐主题yilia

      推荐按照我是如何利用Github Pages搭建起我的博客，细数一路的坑这篇教程进行安装，因为作者写的比较详细，如果遇到一些问题，可以自行搜索解决或者参考其他教程。

      1.2 我遇到的一些坑。

• 前面安装nvm,node.js应该没有太多的问题。我遇到的主要问题集中在将本地的hexo产生的文件同步到github以及后面hexo yilia主题配置的问题。hexo主要有hexo init,hexo g,hexo s,hexo d,hexo clean,hexo new等命令，分别表示初始化,生成静态文件,开启本地服务器,在浏览器预览,将本地文件同步到关联的github repo,清空缓存,产生新文章。注意在配置好hexo以及关联好github repo之后，最好每次执行hexo g,hexo d之前先执行一下hexo clean清空一下缓存，否则可能你输入博客的网址无法查看到你修改之后的页面。比如我当时弄了半天都没法正常查看我的博客主页，一直提示404,找不到github pages。不过我后来关闭了一下浏览器，执行了一下hexo clean就可以正常查看了。所以你如果遇到问题，不妨关闭浏览器重新打开，或者多刷新几次，说不定就好了。

• yilia的配置。这个其实可以查看yilia的官方github,讲的比较详细。其实最主要就是装好了yilia之后，修改hexo的全局_config.yml配置文件以及themes/yilia/_config.yml文件。至于配置参数怎么写，yilia的官方配置文件都给你写好了，照葫芦画瓢改成你自己的就可以了。但是特别需要注意的是!!!:这里有两个_config.yml文件，一个是hexo全局的，还有一个是yilia的，一定要区分清楚!在全局配置文件里，你只需要加上下面的配置条件:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  jsonContent: meta: false pages: false posts: title: true date: true path: true text: false raw: false content: false slug: false updated: false comments: false link: false permalink: false excerpt: false categories: false tags: true

• 而在yilia的配置文件里，你才需要按照yilia官方文档那样修改yilia主题的配置参数。想我当时就是不小心把yilia的配置命令写到全局_config.yml文件里了，搞了半天主题一直都不变，最后才发现写错文件了，真的是。。。。另外还有一个问题是如果你使用hexo s在本地浏览器预览，可能会发现图像url没法正常解析(图像无法显示)以及图标中文乱码的情况(我自己碰到了)，所以如果你也碰到了一样的问题，直接去打开你的博客主页浏览应该就好了。(原因不详)

• 最后知乎上还有一篇文章手把手教你建github技术博客by hexo写的还是不错的，有些详细的yilia配置细节可以参考下,比如yilia博文添加多个tags是[tag1,tag2]这样的形式而不是tag1,tag2等等。
  

  2. 成果展示

  
      我的github博客主页是Lyrichu’s Blog,原来的wordpress搭建的博客后面估计不会维护了。以后主要在博客园和github博客写文章了。