python优化算法库

A. 对于python 的科学计算有哪些提高运算速度的技

一：学会正确使用numpy scipy。 numpy scipy写好的绝不自己写，比如矩阵运算等操作，pylab的实现还算不错。各种函数都有，尽量使用他们可以避免初学者大部分的速度不足问题。因为这些函数大部分都是预编译好的。
根据我几年前的测试，python的矩阵运算速度并不慢，(因为你运行的是动态链接库里面的函数而不是脚本）比mathematica快，和matlab持平。
大部分新手不擅长看文档啥都自己造轮子是不好的。当然老手把效率写的比开源库高也不算啥新闻，毕竟有对特定程序的优化
二：减少for的使用，多使用向量化函数，np.vectorlize可以把函数变成对数组逐元素的操作，比for效率高几个华莱士。
三：对内存友好，操作大矩阵的时候减少会引起整矩阵对此的操作
四：系统最慢的大部分时候是io，包括上面说的内存操作和频繁的读入读出以及debug输出。避免他们，在需要实时处理的时候引入类似于gpu的pipeline管线机制或者使用灵活的多线程编程可以起到奇效。
五：matplotlib的绘图效率并不高明，在使用交互绘图（plt.ion）的时候减少不必要的刷新率。

B. Python怎么做最优化

一、概观
scipy中的optimize子包中提供了常用的最优化算法函数实现。我们可以直接调用这些函数完成我们的优化问题。optimize中函数最典型的特点就是能够从函数名称上看出是使用了什么算法。下面optimize包中函数的概览：
1.非线性最优化
fmin -- 简单Nelder-Mead算法
fmin_powell -- 改进型Powell法
fmin_bfgs -- 拟Newton法
fmin_cg -- 非线性共轭梯度法
fmin_ncg -- 线性搜索Newton共轭梯度法
leastsq -- 最小二乘
2.有约束的多元函数问题
fmin_l_bfgs_b ---使用L-BFGS-B算法
fmin_tnc ---梯度信息
fmin_cobyla ---线性逼近
fmin_slsqp ---序列最小二乘法
nnls ---解|| Ax - b ||_2 for x>=0
3.全局优化
anneal ---模拟退火算法
brute --强力法
4.标量函数
fminbound
brent
golden
bracket
5.拟合
curve_fit-- 使用非线性最小二乘法拟合
6.标量函数求根
brentq ---classic Brent (1973)
brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出这个算法的人名
bisect ---二分法
newton ---牛顿法
fixed_point
7.多维函数求根
fsolve ---通用
broyden1 ---Broyden’s first Jacobian approximation.
broyden2 ---Broyden’s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixing
excitingmixing ---tuned diagonal Jacobian approximationlinearmixing ---scalar Jacobian approximationdiagbroyden ---diagonal Broyden Jacobian approximation8.实用函数
line_search ---找到满足强Wolfe的alpha值
check_grad ---通过和前向有限差分逼近比较检查梯度函数的正确性二、实战非线性最优化
fmin完整的调用形式是：
fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None)不过我们最常使用的就是前两个参数。一个描述优化问题的函数以及初值。后面的那些参数我们也很容易理解。如果您能用到，请自己研究。下面研究一个最简单的问题，来感受这个函数的使用方法：f(x)=x**2-4*x+8，我们知道，这个函数的最小值是4，在x=2的时候取到。
from scipy.optimize import fmin #引入优化包def myfunc(x):
return x**2-4*x+8 #定义函数
x0 = [1.3] #猜一个初值
xopt = fmin(myfunc, x0) #求解
print xopt #打印结果
运行之后，给出的结果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
程序准确的计算得出了最小值，不过最小值点并不是严格的2，这应该是由二进制机器编码误差造成的。
除了fmin_ncg必须提供梯度信息外，其他几个函数的调用大同小异，完全类似。我们不妨做一个对比：
from scipy.optimize import fmin,fmin_powell,fmin_bfgs,fmin_cgdef myfunc(x):
return x**2-4*x+8
x0 = [1.3]
xopt1 = fmin(myfunc, x0)
print xopt1
print
xopt2 = fmin_powell(myfunc, x0)
print xopt2
print
xopt3 = fmin_bfgs(myfunc, x0)
print xopt3
print
xopt4 = fmin_cg(myfunc,x0)
print xopt4
给出的结果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 53
1.99999999997
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 12
Gradient evaluations: 4
[ 2.00000001]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 15
Gradient evaluations: 5
[ 2.]
我们可以根据给出的消息直观的判断算法的执行情况。每一种算法数学上的问题，请自己看书学习。个人感觉，如果不是纯研究数学的工作，没必要搞清楚那些推导以及定理云云。不过，必须了解每一种算法的优劣以及能力所及。在使用的时候，不妨多种算法都使用一下，看看效果分别如何，同时，还可以互相印证算法失效的问题。
在from scipy.optimize import fmin之后，就可以使用help(fmin)来查看fmin的帮助信息了。帮助信息中没有例子，但是给出了每一个参数的含义说明，这是调用函数时候的最有价值参考。
有源码研究癖好的，或者当你需要改进这些已经实现的算法的时候，可能需要查看optimize中的每种算法的源代码。在这里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聪明的你肯定发现了，顺着这个链接往上一级、再往上一级，你会找到scipy的几乎所有源码！

C. python人脸识别所用的优化算法有什么

python三步实现人脸识别

Face Recognition软件包

这是世界上最简单的人脸识别库了。你可以通过Python引用或者命令行的形式使用它，来管理和识别人脸。

该软件包使用dlib中最先进的人脸识别深度学习算法，使得识别准确率在《Labled Faces in the world》测试基准下达到了99.38%。

它同时提供了一个叫face_recognition的命令行工具，以便你可以用命令行对一个文件夹中的图片进行识别操作。

特性

在图片中识别人脸

找到图片中所有的人脸

这里是一个例子：

D. python 循环内要处理大量数据时怎么优化

先尝试优化程序的时间复杂度，寻找更有效的算法

确保了算法复杂度在可接受范围之内后，开始进行常数优化，以下是Python优化的几个小技巧：

1. 实测表明，for语句一般比while语句效率更高

2. 同样实测表明，xrange一般比range要高效

3. 如果要存储动态数据（即有可能频繁变动的数据）少用list和str，多用dict

4. 实测表明，

   两个str的连接效率从高到低+=，join，+

   多个str的连接效率从高到低join，+=，+

5. 尽可能使用列表解析表达式和生成器表达式代替循环一遍来构建list

6. 避免使用global关键字，无论是从代码效率还是可移植性的方面考虑

E. Python 中有哪些性能优化方法

合理使用与deep
对于dict和list等数据结构的对象，直接赋值使用的是引用的方式。
而有些情况下需要复制整个对象，这时可以使用包里的和deep，这两个函数的不同之处在于后者是递归复制的。

F. Python科学计算常用的工具包有哪些

1、 NumPy

NumPy几乎是一个无法回避的科学计算工具包，最常用的也许是它的N维数组对象，其他还包括一些成熟的函数库，用于整合C/C++和Fortran代码的工具包，线性代数、傅里叶变换和随机数生成函数等。NumPy提供了两种基本的对象：ndarray(N-dimensional array object)和 ufunc(universal function object)。ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。

2、SciPy：Scientific Computing Tools for Python

“SciPy是一个开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。其功能与软件MATLAB、Scilab和GNU Octave类似。 Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。”—-引用自“Python机器学习库”

3、 Matplotlib

matplotlib 是python最着名的绘图库，它提供了一整套和matlab相似的命令API，十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件，嵌入GUI应用程序中。Matplotlib可以配合ipython shell使用，提供不亚于Matlab的绘图体验，总之用过了都说好。

关于Python科学计算常用的工具包有哪些，环球青藤小编就和大家分享到这里了，学习是永无止境的，学习一项技能更是受益终身，所以，只要肯努力学，什么时候开始都不晚。如果您还想继续了解关于python编程的学习方法及素材等内容，可以点击本站其他文章学习。

G. python有没有简单的遗传算法库

首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。

以目标式子 y = 10 * sin(5x) + 7 * cos(4x)为例，计算其最大值

首先是初始化，包括具体要计算的式子、种群数量、染色体长度、交配概率、变异概率等。并且要对基因序列进行初始化

[python]view plain

• pop_size=500#种群数量

• max_value=10#基因中允许出现的最大值

• chrom_length=10#染色体长度

• pc=0.6#交配概率

• pm=0.01#变异概率

• results=[[]]#存储每一代的最优解，N个二元组

• fit_value=[]#个体适应度

• fit_mean=[]#平均适应度

• pop=geneEncoding(pop_size,chrom_length)




其中genEncodeing是自定义的一个简单随机生成序列的函数，具体实现如下

[python]view plain

• defgeneEncoding(pop_size,chrom_length):

• pop=[[]]

• foriinrange(pop_size):

• temp=[]

• forjinrange(chrom_length):

• temp.append(random.randint(0,1))

• pop.append(temp)

• returnpop[1:]

编码完成之后就是要进行个体评价，个体评价主要是计算各个编码出来的list的值以及对应带入目标式子的值。其实编码出来的就是一堆2进制list。这些2进制list每个都代表了一个数。其值的计算方式为转换为10进制，然后除以2的序列长度次方减一，也就是全一list的十进制减一。根据这个规则就能计算出所有list的值和带入要计算式子中的值，代码如下

[python]view plain

• #0.0coding:utf-80.0

• #解码并计算值

• importmath

• defdecodechrom(pop,chrom_length):

• temp=[]

• foriinrange(len(pop)):

• t=0

• forjinrange(chrom_length):

• t+=pop[i][j]*(math.pow(2,j))

• temp.append(t)

• returntemp

• defcalobjValue(pop,chrom_length,max_value):

• temp1=[]

• obj_value=[]

• temp1=decodechrom(pop,chrom_length)

• foriinrange(len(temp1)):

• x=temp1[i]*max_value/(math.pow(2,chrom_length)-1)

• obj_value.append(10*math.sin(5*x)+7*math.cos(4*x))

• returnobj_value

有了具体的值和对应的基因序列，然后进行一次淘汰，目的是淘汰掉一些不可能的坏值。这里由于是计算最大值，于是就淘汰负值就好了

[python]view plain

• #0.0coding:utf-80.0

• #淘汰（去除负值）

• defcalfitValue(obj_value):

• fit_value=[]

• c_min=0

• foriinrange(len(obj_value)):

• if(obj_value[i]+c_min>0):

• temp=c_min+obj_value[i]

• else:

• temp=0.0

• fit_value.append(temp)

• returnfit_value




然后就是进行选择，这是整个遗传算法最核心的部分。选择实际上模拟生物遗传进化的优胜劣汰，让优秀的个体尽可能存活，让差的个体尽可能的淘汰。个体的好坏是取决于个体适应度。个体适应度越高，越容易被留下，个体适应度越低越容易被淘汰。具体的代码如下

[python]view plain

• #0.0coding:utf-80.0

• #选择

• importrandom

• defsum(fit_value):

• total=0

• foriinrange(len(fit_value)):

• total+=fit_value[i]

• returntotal

• defcumsum(fit_value):

• foriinrange(len(fit_value)-2,-1,-1):

• t=0

• j=0

• while(j<=i):

• t+=fit_value[j]

• j+=1

• fit_value[i]=t

• fit_value[len(fit_value)-1]=1

• defselection(pop,fit_value):

• newfit_value=[]

• #适应度总和

• total_fit=sum(fit_value)

• foriinrange(len(fit_value)):

• newfit_value.append(fit_value[i]/total_fit)

• #计算累计概率

• cumsum(newfit_value)

• ms=[]

• pop_len=len(pop)

• foriinrange(pop_len):

• ms.append(random.random())

• ms.sort()

• fitin=0

• newin=0

• newpop=pop

• #转轮盘选择法

• whilenewin<pop_len:

• if(ms[newin]<newfit_value[fitin]):

• newpop[newin]=pop[fitin]

• newin=newin+1

• else:

• fitin=fitin+1

• pop=newpop

• 以上代码主要进行了3个操作，首先是计算个体适应度总和，然后在计算各自的累积适应度。这两步都好理解，主要是第三步，转轮盘选择法。这一步首先是生成基因总数个0-1的小数，然后分别和各个基因的累积个体适应度进行比较。如果累积个体适应度大于随机数则进行保留，否则就淘汰。这一块的核心思想在于：一个基因的个体适应度越高，他所占据的累计适应度空隙就越大，也就是说他越容易被保留下来。

选择完后就是进行交配和变异，这个两个步骤很好理解。就是对基因序列进行改变，只不过改变的方式不一样

交配：

[python]view plain

• #0.0coding:utf-80.0

• #交配

• importrandom

• defcrossover(pop,pc):

• pop_len=len(pop)

• foriinrange(pop_len-1):

• if(random.random()<pc):

• cpoint=random.randint(0,len(pop[0]))

• temp1=[]

• temp2=[]

• temp1.extend(pop[i][0:cpoint])

• temp1.extend(pop[i+1][cpoint:len(pop[i])])

• temp2.extend(pop[i+1][0:cpoint])

• temp2.extend(pop[i][cpoint:len(pop[i])])

• pop[i]=temp1

• pop[i+1]=temp2



• 变异：

[python]view plain

• #0.0coding:utf-80.0

• #基因突变

• importrandom

• defmutation(pop,pm):

• px=len(pop)

• py=len(pop[0])

• foriinrange(px):

• if(random.random()<pm):

• mpoint=random.randint(0,py-1)

• if(pop[i][mpoint]==1):

• pop[i][mpoint]=0

• else:

• pop[i][mpoint]=1



• 整个遗传算法的实现完成了，总的调用入口代码如下

[python]view plain

• #0.0coding:utf-80.0

• importmatplotlib.pyplotasplt

• importmath

• fromselectionimportselection

• fromcrossoverimportcrossover

• frommutationimportmutation

• frombestimportbest

• print'y=10*math.sin(5*x)+7*math.cos(4*x)'

• #计算2进制序列代表的数值

• defb2d(b,max_value,chrom_length):

• t=0

• forjinrange(len(b)):

• t+=b[j]*(math.pow(2,j))

• t=t*max_value/(math.pow(2,chrom_length)-1)

• returnt

• pop_size=500#种群数量

• max_value=10#基因中允许出现的最大值

• chrom_length=10#染色体长度

• pc=0.6#交配概率

• pm=0.01#变异概率

• results=[[]]#存储每一代的最优解，N个二元组

• fit_value=[]#个体适应度

• fit_mean=[]#平均适应度

• #pop=[[0,1,0,1,0,1,0,1,0,1]foriinrange(pop_size)]

• pop=geneEncoding(pop_size,chrom_length)

• foriinrange(pop_size):

• obj_value=calobjValue(pop,chrom_length,max_value)#个体评价

• fit_value=calfitValue(obj_value)#淘汰

• best_indivial,best_fit=best(pop,fit_value)#第一个存储最优的解,第二个存储最优基因

• results.append([best_fit,b2d(best_indivial,max_value,chrom_length)])

• selection(pop,fit_value)#新种群复制

• crossover(pop,pc)#交配

• mutation(pop,pm)#变异

• results=results[1:]

• results.sort()

• X=[]

• Y=[]

• foriinrange(500):

• X.append(i)

• t=results[i][0]

• Y.append(t)

• plt.plot(X,Y)

• plt.show()

• 最后调用了一下matplotlib包，把500代最优解的变化趋势表现出来。



完整代码可以在github查看

欢迎访问我的个人博客

阅读全文

H. 使用流行的遗传算法python库是哪个

建议使用由华南农业大学、暨南大学、华南理工大学高校硕博学生联合团队推出的Python高性能遗传和进化算法工具箱：Geatpy。它是目前进化计算领域与platemo、matlab遗传算法工具箱等有相当的权威和影响力的高性能实用型进化算法工具箱，而其效率和易用性居于领先地位。

目前已得到多所高校研究生实验室以及企业采用，为相关领域的研究和应用注入了全新的活力。

它支持GA、DE、ES等进化算法，支持单目标、多目标进化优化、复杂约束优化等问题的求解，提供丰富的遗传算法和多目标进化优化算法模板，采用高性能的C内核和mkl矩阵运算，提供功能强大的开源进化算法框架，尤其适合数学建模和研究进化算法的研究生们。

官网：Geatpy

多目标优化求解案例：

使用方法：

第一步：实例化一个问题类把待优化的问题写在里面。

第二步：编写执行脚本调用遗传或其他进化算法模板，完成问题的求解。

官网教程：Geatpy教程

I. 有没有可以并行计算的python科学计算库

因为我的程序中需要并行的是优化计算的evaluation部分，所以如果能够找到一些支持并行优化的库就可以。
从python官网上，可以找到一个DEAP库（git上有），利用map进行并行计算。
这个库的优点是，documents和例子是非常详细的。很多函数，用户可以根据自己的需求修改，接口还是很好用的。
DEAP中是通过调用了一个scoop库（git上有）中的map函数来进行并行计算的。
如果你的项目不是优化，可以直接用scoop来做并行计算，scoop的documents也是蛮详细的。

J. 用python处理一个1G左右的数据集，运行速度非常慢，怎样优化

给你几点个人的建议哈：

考虑拿C或C++重写.

考虑并行搞，找个hadoop集群，写成maprece程序跑 放在hadoop上跑，更多数据都不怕.

考虑升级机器，多搞点内存，然后东西尽量放在内存里搞.

考虑程序优化.

希望可以帮助到你哦，这只是我的一个建议哈！