当前位置：Gxlcms > Python > python实现各种最优化算法

python实现各种最优化算法

时间：2021-07-01 10:21:17 帮助过：91人阅读

python视频教程栏目介绍各种最优化算法

相关免费学习推荐：python视频教程

二分法

函数详见rres，此代码使该算法运行了两次

  1. def asdf(x):
  2.     rres=8*x**3-2*x**2-7*x+3
  3.     return rres
  4. i=2
  5. left=0
  6. right=1
  7. while i>0 :
  8.     i = i-1
  9.     ans = 0.1
  10.     mid1 = (left + right + ans) / 2
  11.     mid2 = (left + right - ans) / 2
  12.     a=asdf(mid1)
  13.     c=asdf(mid2)
  14.     if a > c :
  15.         right = mid1
  16.     else :
  17.         left = mid2
  18. b=(left+right) / 2
  19. print("左极限=%s,右极限=%s,极小值x=%s"%(left,right,b))
  1. 左极限=0.45,右极限=0.775,极小值x=0.6125

收获：
这是我第一个实现的代码。学习完该算法以后，逻辑框架基本上就有了，剩下需要明确的就是对应的python的语言。于是我就开始了查找“如何定义函数”（详见mofan的优酷），“循环体”和“if条件语句”的格式（https://blog.csdn.net/qq_39407518/article/details/79822498）“数学符号”（详见mofan的优酷），以及print的使用

1.def是python中指定义，一般用来定义函数，如果需要深度学习搭建网络可用来定义网络。值得注意的一点是

return必须要加在函数后面另起一行。

我不清楚为什么，但是如果没有加的话，那个函数公式就是一个花瓶，就像一个结果输不出去。

2.最坑的就是逻辑。一开始逻辑没理清楚，或者说在代码上有疏漏，导致我将left和right放在了循环体里，结果可想而知。不过也是因为这个错误，我知道pycharm中的debug怎么用，挺简单的，百度一下就出来了。

3.不知道什么原因，看的莫烦视频中的print多个变量一起输出是没有办法在我的pycharm中使用的，出来的结果很奇怪。可能是因为我是win10不是ios吧。print如果多个变量一起输出必须是print("名字：%s,名字2：%s"%(a,b))结果输出就是名字：a ,名字2：b

问题：1.为什么要加return？

return的意思是输出这个def里面任意一个变量值作为结果显示。一般情况而言，是输出函数的关系式的命名，这样当你调用这个函数的时候，变量对应的函数值才能显示出来，否则只运行没有结果，不会有效果。

格点法——三点等分法

  1. import numpy as np
  2. def qwer(x):
  3.     third = np.exp(x) - 5*x
  4.     return third
  5. left = 1
  6. right = 2
  7. mid1 =float(left+right) / 2
  8. mid2 = (left+mid1) / 2
  9. mid3 = (mid1+right) /2
  10. a = qwer(mid1)
  11. b = qwer(mid2)
  12. c = qwer(mid3)
  13. i = 5
  14. while i > 0:
  15.     i=i-1
  16.     if a > b:
  17.         if c > b :
  18.             #b
  19.             right = mid1
  20.             mid1 = mid2
  21.             a=b
  22.             mid2 = (left + mid1) / 2
  23.             mid3 = (mid1 + right) / 2
  24.             b = qwer(mid2)
  25.             c = qwer(mid3)
  26.         else:#b>c
  27.             #c
  28.             left = mid1
  29.             mid1 = mid3
  30.             a = c
  31.             mid2 = (left + mid1) / 2
  32.             mid3 = (mid1 + right) / 2
  33.             b = qwer(mid2)
  34.             c = qwer(mid3)
  35.     else:#b>a
  36.             if a > c:
  37.                 #C
  38.                 left = mid1
  39.                 mid1 = mid3
  40.                 a = c
  41.                 mid2 = (left + mid1) / 2
  42.                 mid3 = (mid1 + right) / 2
  43.                 b = qwer(mid2)
  44.                 c = qwer(mid3)
  45.             else:#b>a&c>a
  46.                 # a
  47.                 left = mid2
  48.                 right = mid3
  49.                 mid2 = (left + mid1) / 2
  50.                 mid3 = (mid1 + right) / 2
  51.                 b = qwer(mid2)
  52.                 c = qwer(mid3)
  53. print("最小值=%s"%mid1)
  54. print("函数值=%s"%a)
  1. 最小值=1.609375
  2. 函数值=-3.047189552275773

关于python中数据变量。第一遍运行结果出现很明显不对，于是我采用了debug。结果发现，mid1处一直为1而不是1.5，于是就开始了解数据变量。起初我猜测python默认所有变量为整型，但是根据二分法的结果我意识到此猜测不对，所以要改整个file的变量格式没有必要。所以我就在mid1式子前面加了一个float，结果就显示为1.5了。但是如果我将整个式子用（）括起来，前面加float，结果还是1。我不太理解为什么。不过我知道了python的数据格式是根据输入量决定的，也就是说你的输入量如果是整型，那么与其直接相关的计算输出结果一定是整型，而且还是不采用进位的整型。在我没有采用+float/+.0这两种方法之前，mid1~3全部是整型。

  1. left = 1.0
  2. right = 2.0
  3. mid1 =(left+right) / 2

或者不再mid1前面加float,直接将输入量后面点个点就行
真的很想吐槽一下print,好麻烦啊啊啊啊每次都得弄个%s,而且有时候还不能放一起！！！！

Fibonacci法

  1. def fibonacci(n):
  2.     i=0
  3.     a = 0
  4.     b = 1
  5.     for i in range(n):
  6.         i=i+1
  7.         c = a+b
  8.         a = b
  9.         b = c
  10.     return c
  11. def bn(x):
  12.     ert = x**2 - 6*x + 2
  13.     return ert
  14. z = 2
  15. p = 0
  16. left = 0.00000
  17. right = 10.00000
  18. L1 = right - left
  19. while z < 100:
  20.     m = fibonacci(z)
  21.     l = L1/m
  22.     k = 1.000/m
  23.     if k < 0.03:
  24.         print("n=%s,Fn=%s"%(z,m))
  25.         L2 = l*fibonacci(z-1)
  26.         t = left + L2
  27.         r = right -L2
  28.         while p < 3:
  29.             p = p + 1
  30.             l3 = t - r
  31.             e= bn(t)
  32.             o = bn(r)
  33.             if e>o :
  34.                 right = t
  35.                 t = r
  36.                 r = left + l3
  37.             else:#o>e
  38.                 left = r
  39.                 r = t
  40.                 t = right - l3
  41.         break
  42.     else:
  43.         z = z + 1
  44. okk=(left+right)/2
  45. okky=bn(okk)
  46. print(left)
  47. print(right)
  48. print("极小值x=",okk)
  49. print("极小值y=",okky)

不要问我掌握了什么，要问我现在写完这个代码后有多么的爱python的精度表示 :-)我决定以后只要再编写数学公式的代码都将输入量的小数学点后面补很多0
fibonacci函数定义，每次debug后我的手都是抖的O(∩_∩)O~

黄金分割法

  1. def gold(x):
  2.     gg= x**2 - 6*x + 9
  3.     return gg
  4. left = 1
  5. right = 7
  6. ans = 0.4
  7. a = left + 0.618 * (right - left)
  8. b = left + 0.382*(right - left)
  9. gga = gold(a)
  10. ggb = gold(b)
  11. i = 0
  12. while i < 7:
  13.     print("i=%s" % i)
  14.     print("left=%s,right=%s" % (left, right))
  15.     print("x左=%s,x右=%s" % (a, b))
  16.     print("y左=%s,y右=%s" % (ggb, gga))
  17.     c = right - left
  18.     if c > 0.4:
  19.         i = i + 1
  20.         if gga > ggb:
  21.             right = a
  22.             a = b
  23.             b = left + 0.382*(right - left)
  24.             gga = ggb
  25.             ggb = gold(b)
  26.         else:#gga<ggb
  27.             left = b
  28.             b = a
  29.             a = left + 0.618 * (right - left)
  30.             ggb = gga
  31.             gga = gold(a)
  32.     else:
  33.         break

不知道自己什么时候有的强迫症，只要是代码下面有“~”我就必须要消掉。笑哭。这个很简单，前四个除了费波纳茨，都很简单。

间接法——二次插值法

  1. def yy(x):
  2.     y=x**4-4*x**3-6*x**2-16*x+4
  3.     return y
  4. def xing(xm1,xm2,xm3,fm1,fm2,fm3):
  5.     yxxx=0.5000*((xm2**2-xm3**2)*fm1+(xm3**2-xm1**2)*fm2+(xm1**2-xm2**2)*fm3)/((xm2-xm3)*fm1+(xm3-xm1)*fm2+(xm1-xm2)*fm3)
  6.     return yxxx
  7. x1 = -1.0000
  8. f1 = yy(x1)
  9. x3 = 6
  10. f3 = yy(x3)
  11. x2 = 0.50000*(x1+x3)
  12. f2 = yy(x2)
  13. xp = xing(x1,x2,x3,f1,f2,f3)
  14. fp = yy(xp)
  15. a = abs(xp-x2)
  16. while abs(xp-x2) > 0.05000:
  17.     a = abs(xp - x2)
  18.     if xp > x2:
  19.         if fp > f2:
  20.             x3=xp
  21.             f3=fp
  22.             xp = xing(x1, x2, x3, f1, f2, f3)
  23.             fp = yy(xp)
  24.             print("ans=%s" % a)
  25.             print("left=%s,right=%s" % (x1, x3))
  26.             print("x*=%s,fp*=%s" % (xp, fp))
  27.             print("x2=%s,f2=%s" % (x2, f2))
  28.             print("******************")
  29.         else:#f2>fp
  30.             x1 = x2
  31.             f1 = f2
  32.             x2 = xp
  33.             f2 = fp
  34.             xp = xing(x1, x2, x3, f1, f2, f3)
  35.             fp = yy(xp)
  36.             print("ans=%s" % a)
  37.             print("left=%s,right=%s" % (x1, x3))
  38.             print("x*=%s,fp*=%s" % (xp, fp))
  39.             print("x2=%s,f2=%s" % (x2, f2))
  40.             print("******************")
  41.     else:#xp<x2
  42.         if fp > f2:
  43.             x1 = xp
  44.             f1 = fp
  45.             xp = xing(x1, x2, x3, f1, f2, f3)
  46.             fp = yy(xp)
  47.             print("ans=%s" % a)
  48.             print("left=%s,right=%s" % (x1, x3))
  49.             print("x*=%s,fp*=%s" % (xp, fp))
  50.             print("x2=%s,f2=%s" % (x2, f2))
  51.             print("******************")
  52.         else:
  53.             x3 = x2
  54.             f3 = f2
  55.             x2 = xp
  56.             f2 = fp
  57.             xp = xing(x1, x2, x3, f1, f2, f3)
  58.             fp = yy(xp)
  59.             print("ans=%s" % a)
  60.             print("left=%s,right=%s" % (x1, x3))
  61.             print("x*=%s,fp*=%s" % (xp, fp))
  62.             print("x2=%s,f2=%s" % (x2, f2))
  63.             print("******************")

这个公式看起来很麻烦，便写的时候更要谨慎。我上回把那个2搁在了分号下面，结果很大，所以还是换算成0.5更好（PS：勿忘那长河般的0）。
虽然代码很长，但是主要是因为print太多。本打算在开头print，最后结果会漏掉最后一部分。懒得想其他办法了，直接就这样吧

间接法——牛顿法

  1. def fd(x):
  2.     y = 4*x**3-12*x**2-12*x-16
  3.     return y
  4. def fdd(x):
  5.     ys = 12*x**2-24*x-12
  6.     return ys
  7. i = 1
  8. x0 = 3.00000
  9. ans = 0.001
  10. while i < 7:
  11.     fd0 = fd(x0)
  12.     fdd0 = fdd(x0)
  13.     if abs(fd0) > ans:
  14.         x1 = x0 - (fd0/fdd0)
  15.         x0 = x1
  16.         print("次数：%s,所得的值x:%s"%(i,x1))
  17.         i = i + 1
  18.     else:#fd0<0.001
  19.         print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
  20.         print("Bingo!顺利通关！祝您开学愉快！")
  21.         print("Boss  X=%s"%x0)
  22.         break

一开始while里面<写成了>,导致run不出来。继而，debug也没法用。在网上一查才知道 “没联网”+“没选断点”。最后想尝试将else里面的内容输出来，结果发现run以后被刷屏了。于是改成i<7以后还是不行，于是想着加一个break跳出循环，结果成效了。
然后刚刚由debug了一下，才知道原来是i+1在if里面，因为没有办法+1，所以i=6一直存在，就不断循环。因为加break也好，i+1也好，都可以。

就在一个半小时前，我成功搞完了最优化六大代码，纯手打，无外力。开心!

这是我第一组自己实现的python代码，就是数学公式用python语言组装起来。刚开始的时候知道大概需要在语言中体现什么，但不太清楚。于是我就在网上找了几个二分法的，他们都各有不同，但框架都差不多，不过如果要用到我们的那个公式里还需要改变很多。然后我就开始分析我们的题，我发现大体需要两部分，一部分函数定义，一部分循环体。但我不知道如何定义函数，如何写数学公式，如何弄变量，也就是说一些小点不太会，所以我选择直接百度。因为我知道自己阅读的能力不错，相比于从视频中提取要素，我更擅长通过阅读获得要点。有目的性地找知识点，掌握地更牢固。
于是我就开始了第一个——二分法的编写。我发现，自己出现了很多错误而且有很多地方都很基础。但我依然没选择视频，而是将这些问题直接在百度上找，因为视频讲完或许你也没找到点。当然，这是一步一步走的，不是直接就将程序摆上去，一点一点改。
随着前两个的成功，我发现自己对于这些代码有了自信，似乎看透了他们的伪装，抓住了本质。除此之外，我还意识到自己自从8月份以后，学习能力似乎提高了不少，而且有了更为有效的学习方法。各方面都有了一定的觉醒。除了第一个找了几个牛头不对马嘴的代码，其他都是根据自己的逻辑写，逻辑通下来以后，对应语言中某一部分不知道如何翻译就去百度，其实这几个套路都一样或者说数学公式转化的套路都一样。
我还意识到，汇编其实是最难的语言，目前为止所学到的，因为很多都需要自己去定义，去死抠，需要记住大量的指令且不能灵活变通。但是其他的却只需要将一些对应的记下来就好。python真的挺简单的。而且，我发现自己今天似乎打开了新世界的大门，我爱上了这种充满了灵性的东西，充满了严谨的美丽，还有那未知的变化，我发现我似乎爱上了代码。可能不仅仅局限于python，这些语言都充满了挑战性。我觉得当你疑惑的时候，就需要相信直觉，至少我发现它很准

以上就是python实现各种最优化算法的详细内容，更多请关注gxlcms其它相关文章！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！