weixin_34206899
weixin_34206899

sopt:一个简单的python最优化库

引言

    最近有些朋友总来问我有关遗传算法的东西，我是在大学搞数学建模的时候接触过一些最优化和进化算法方面的东西，以前也写过几篇博客记录过,比如遗传算法的C语言实现(一):以非线性函数求极值为例和C语言实现粒子群算法(PSO)一等，如果对原理有兴趣的话可以去我的博客具体查看:Lyrichu's Blog。所以突发奇想，干脆把以前写的一些进化算法比如遗传算法(GA),粒子群算法(PSO),模拟退火算法(SA)以及最近看的基于梯度的一些优化算法比如Gradient Descent,SGD,Momentum等整理一下，写成一个python库，方便那些有需要的朋友使用。断断续续花了几天的时间，初步完成了一些基本功能，这里简单介绍一下。

sopt 简介


     sopt是simple optimization的简称，目前我已经将代码托管到pypi,地址是 sopt,可以直接通过pip命令下载安装使用,由于项目只依赖numpy,所以在windows和linux环境下安装都很方便，直接 pip install sopt即可。项目的github地址是 sopt。目前sopt包含的优化方法如下:

  • 遗传算法(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的一个简单使用实例:

    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()

    运行结果如下:

    -------------------- 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:
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所示:

    图1 SGA 运行结果
    上面定义的目标函数为\(f(x_1,x_2)=(x_1-1)^2+(sin(x_2)-0.5)^4+2\),其中\(0,函数的最小值点为(1,0.5236),最小值为2,与寻找到的最小值点(1.00488759 0.45356794)以及最小值2.00003849823336是非常接近的。
    SGA类的全部参数定义如下:
  • 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更加一般的遗传算法实现，其对于编码方式，选择方式，交叉方式以变异方式等会有更多的支持。首先还是看一个例子:

    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()

    上面代码的运行结果为:

    GA costs 6.8320 seconds!
-------------------- GA config is: --------------------
func:
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函数，其他参数设置保持不变，得到的结果如下:

    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:
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是每代最优值的计算结果:

    图2 GA Rosenbrock 函数运行200代寻优结果
    替换成Rosenbrock函数之后，函数的运行时间从6秒多减少到1秒多(函数变量个数明显减少了),这说明GA的运行时间与目标函数的变量个数是显著相关的。最后找到的全局极大值点为(-2.04776953,-2.04537109)和真实全局极大值点(-2.048,-2.048)已经很接近了。
        SGA类是GA类的父类，所以GA类和SGA类有一些公共的属性，比如generations,population_size,func_type等。和SGA一样的参数这里就不再列举了，如下是GA特有的一些参数:
  • 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\),其复杂约束函数应该这样定义:

    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）二,这里不再赘述。还是先看一个实例代码:

    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()

    运行结果为:

    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:
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
    图3 PSO 求解 quadratic11 200代运行结果 上面的代码意图应该是非常明显的,目标函数是\(quadratic11\),最终求得的最小值点几乎就是全局最小值点。下面是PSO类中所有参数的具体定义:
  • 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的使用实例如下:

    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()

    运行结果如下:

    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:
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
    图4 SA求解Rosenbrock函数 SA类的具体参数含义如下:
  • 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的使用实例如下:

    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()

    运行结果为:

    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:
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
    图5 Random Walk 求解quadratic50 经过实验发现,Random Walk 具有非常强的全局寻优能力，对于quadratic50这种具有50个变量的复杂目标函数，它也可以很快找到其全局最优点，而且运行速度也很快。RandomWalk类的具体参数含义如下:
  • 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函数求解了带有三个复杂约束条件的最优值:

    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()

    运行结果如下:

    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:[, , ]
func:
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
    图6 GA求解带有三个复杂约束的Rosenbrock函数

    上面的constraints1,constraints2,constraints3是三个预定义的约束条件函数，其定义分别为:\(constraints1:x_1^2 + x_2^2 - 6 \le 0\);\(constraints2:x_1 + x_2 \le 0\);\(constraints3:-2-x_1 - x_2 \le 0\),函数原型为:

    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函数，代码及运行结果如下:

    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()

    运行结果:

    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:
variables_num:2
walk_nums:17
complex_constraints_method:loop
generations:100
generations_nums:2191
complex_constraints:[, , ]
-------------------- 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 Random Walk求解带有三个复杂约束的Rosenbrock函数

    可以发现Random Walk 求解得到的最优解要比GA好，而且运行时间更快，经过实验发现，在所有的优化方法中，不论是求解带复杂约束还是不带复杂约束条件的目标函数，求解效果大体上排序是:Random Walk > PSO > GA > SA 。所以当你在求解具体问题时，不妨多试几种优化方法，然后择优选择。

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


        上面所述的各种优化方法，比如GA,PSO,SA等都是基于随机搜索的优化算法，其计算是不依赖于目标函数的具体形式，也不需要知道其梯度的，更加传统的优化算法是基于梯度的算法，比如经典的梯度下降(上升)法(Gradient Descent)以及其一系列变种。下面就简要介绍sopt中GD,Momentum,AdaGrad,RMSProp以及Adam的实现。关于这些基于梯度的优化算法的具体原理，可以参考我之前的一篇博文深度学习中常用的优化方法。另外需要注意，以下所述的基于梯度的各种优化算法，一般都是用在无约束优化问题里面的，如果是有约束的问题，请选择上面其他的优化算法。下面是GradientDescent的一个使用实例:

    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()

    运行结果为:

    Gradient Descent costs 14.3231 seconds!
-------------------- Gradient Descent config is: --------------------
func_type:min
variables_num:50
func:
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
    图7 GradientDescent 求解quadratic50 下面简要说明以下GradientDescent,Momentum等类中的主要参数,像func,variables_num等含义已经解释很多次了，不再赘述，这里主要介绍各类特有的一些参数。
  1. GradientDescent类:
  • lr:学习率,默认是\(10^{-3}\);
  • epochs:迭代次数，默认是100；
  1. Momentum类:
  • lr:学习率,默认是\(10^{-3}\);
  • beta:Momentum的\(\beta\)参数，默认是0.9;
  • epochs:迭代次数，默认是100；
  1. AdaGrad类:
  • lr:学习率,默认是\(10^{-3}\);
  • eps:极小的一个正数(防止分母为0),默认为\(10^{-8}\);
  • epochs:迭代次数，默认是100；
  1. RMSProp类:
  • lr:学习率,默认是\(10^{-3}\);
  • beta:RMSProp的\(\beta\)参数，默认是0.9;
  • eps:极小的一个正数(防止分母为0),默认为\(10^{-8}\);
  • epochs:迭代次数，默认是100；
  1. 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的一个示例测试:

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

    结果:

    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:
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:http://www.github.com/Lyrichu github blog:http://Lyrichu.github.io 个人博客站点:http://www.movieb2b.com(不再维护)

你可能感兴趣的:(python,数据结构与算法,c/c++)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十一题 互联网打工人no1 C语言程序设计每日一练c语言
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • apache 安装linux windows 墙头上一根草 apacheinuxwindows
    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式     通过二进制文件安装Apache需要的软件有apr,apr-util,pcre  1，安装 apr        下载地址：htt
  • fill_parent、wrap_content和match_parent的区别 Cb123456 match_parentfill_parent
    fill_parent、wrap_content和match_parent的区别:   1）fill_parent   设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 2） wrap_conte
  • 网页自适应设计 天子之骄 htmlcss响应式设计页面自适应
    网页自适应设计        网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
  • [sql server] 分组取最大最小常用sql 一炮送你回车库 SQL Server
    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
  • ImageIO写图片输出到硬盘 3213213333332132 javaimage
    package awt; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imagei
  • 自己的String动态数组 宝剑锋梅花香 java动态数组数组
    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
  • pinyin4j工具类 darkranger .net
    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小 引入pinyin4j-2.5.0.jar包: pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。 本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
  • StarUML学习笔记----基本概念 aijuans UML建模
    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。         模型、视与图（Model, View and Diagram）        &
  • Activiti最终总结 avords Activiti id 工作流
    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 4、TaskDefinitionKey和（ActivityImpl activityId
  • 从省市区多重级联想到的，react和jquery的差别 bee1314 jqueryUIreact
    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。   针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
  • Eclipse快捷键大全 bijian1013 javaeclipse快捷键
    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
  • js 笔记 函数 征客丶 JavaScript
    一、函数的使用 1.1、定义函数变量 var vName = funcation(params){ } 1.2、函数的调用 函数变量的调用：      vName(params); 函数定义时自发调用：(function(params){})(params); 1.3、函数中变量赋值 var a = 'a'; var ff
  • 【Scala四】分析Spark源代码总结的Scala语法二 bit1129 scala
    1. Some操作   在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， Some的文档说明：   /** Class `Some[A]` represents existin
  • java 匿名内部类 BlueSkator java匿名内部类
    组合优先于继承 Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系 继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。   在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用 ljy325 游戏applewindowsXPOS
    Mac mini 型号: MC270CH-A RMB:5,688   Apple 对windows的产品支持不好,有以下问题:   1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响!   2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 &nbs
  • 读《研磨设计模式》-代码笔记-生成器模式-Builder bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF） * 个人理解： * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
  • JIRA与SVN插件安装 chenyu19891124 SVNjira
    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
  • 常用数学思想方法 comsci 工作
      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考   函数思想 　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
  • pl/sql集合类型 daizj oracle集合typepl/sql
    --集合类型 /*   单行单列的数据，使用标量变量   单行多列数据，使用记录   单列多行数据，使用集合（。。。）   *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 */ /*     --集合方法 &n
  • [Ofbiz]ofbiz初用 dinguangx 电商ofbiz
    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 1. 加载测试库 ofbiz内置derby，通过下面的命令初始化测试库 ./ant load-demo (与load-seed有一些区别)   2. 启动内置tomcat ./ant start 或 ./startofbiz.sh 或 java -jar ofbiz.jar &
  • 结构体中最后一个元素是长度为0的数组 dcj3sjt126com cgcc
    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
  • Linux cp 实现强行覆盖 dcj3sjt126com linux
    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一 我们输入alias命令，看看系统给cp起了一个什么别名。 [root@localhost ~]# aliasalias cp=’cp -i’a
  • Memcached(一)、HelloWorld frank1234 memcached
    一、简介 高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。 二、客户端 选择一个memcached客户端，我这里用的是memc
  • Search in Rotated Sorted Array II hcx2013 search
    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given ta
  • Spring4新特性——更好的Java泛型操作API jinnianshilongnian spring4generic type
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装JDK liuxingguome centos
    1、行卸载原来的： [root@localhost opt]# rpm -qa | grep java tzdata-java-2014g-1.el6.noarch java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 [root@localhost
  • 二分搜索专题2-在有序二维数组中搜索一个元素 OpenMind 二维数组算法二分搜索
    1,设二维数组p的每行每列都按照下标递增的顺序递增。 用数学语言描述如下：p满足 (1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); (2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 2,问题： 给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 3,算法分析： (
  • java 随机数 Math与Random SaraWon javaMathRandom
    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 产生1到10之间的随机数的两种实现方式： //Math Math.roun
  • oracle创建表空间 tugn oracle
    create temporary tablespace TXSJ_TEMP   tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'   size 32m   autoextend on   next 32m maxsize 2048m   extent m
  • 使用Java8实现自己的个性化搜索引擎 yangshangchuan javasuperword搜索引擎java8全文检索
    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他