本文将重点介绍如何用Go语言实现遗传算法。如果你还没有参加过GoLang Tour，我还建议你快速看一下这门语言的介绍。话不多说，让我们开始从代码说起吧!

出于好玩的心态，我决定学习一下Go语言。我认为学习新语言***的方法就是深入学习，并且尽可能多犯错误。这样做虽然可能会很慢，但是可以确保在后面的过程中再也不会出现编译的错误。

Go语言与我习惯的其他语言不同。Go更喜欢自己单独实现，而其他像Java这类语言更喜欢继承。其实在Go语言里面根本没有继承这种概念，因为它压根就没有对象这一说法。比如说C语言，它有结构体，但是没有类。但是这样它还是可以有像“构造者”这样的常见思想和设计模式(一种在这种情况下有序地产生结构体的方式)。

Go语言如何实现遗传算法 Go语言如何实现遗传算法（go语言算法实战） Go语言 算法 代码 第1张

Go语言坚决拥护组合(composition)，同时也很反对继承的做法，在网络上引起了强烈的讨论，同时也让人们重新思考了语言该往哪个方向发展。所以，从这个角度来看，Go语言与其它语言的差别可能也没有那么大。

本文将重点介绍如何用Go语言实现遗传算法。如果你还没有参加过GoLang Tour，我还建议你快速看一下这门语言的介绍。

话不多说，让我们开始从代码说起吧!***个例子与我以前做过的很类似：找到一个二次的最小值。

  1. typeGeneticAlgorithmSettingsstruct{
  2. PopulationSizeint
  3. MutationRateint
  4. CrossoverRateint
  5. NumGenerationsint
  6. KeepBestAcrossPopulationbool
  7. }
  9. typeGeneticAlgorithmRunnerinterface{
  10. GenerateInitialPopulation(populationSizeint)[]interface{}
  11. PerformCrossover(individual1,individual2interface{},mutationRateint)interface{}
  12. PerformMutation(individualinterface{})interface{}
  13. Sort([]interface{})
  14. }

我立马定义了一组设置，以便在稍后启动的算法中用到。

第二部分的GeneticAlgorithmRunner这个看起来有点奇怪。GeneticAlgorithmRunner是一个接口，询问如何生成初始种群，执行corssovers和mutataions，并对答案进行排序，以便在Population中保持***的个体，这样下一代才会更加优秀。我认为这看起来很奇怪，因为“接口”通常用于面向对象的语言，通常会要求对象实现某些特性和方法。这里没有什么差别。这一小段代码实际上是在说，它正在请求一些东西来定义这些方法的细节。我是这样做的:

  1. typeQuadraticGAstruct{}
  3. func(lQuadraticGA)GenerateInitialPopulation(populationSizeint)[]interface{}{
  4. initialPopulation:=make([]interface{},0,populationSize)
  5. fori:=0;i<populationSize;i++{
  6. initialPopulation=append(initialPopulation,makeNewEntry())
  7. }
  8. returninitialPopulation
  9. }
  11. func(lQuadraticGA)PerformCrossover(result1,result2interface{},_int)interface{}{
  12. return(result1.(float64)+result2.(float64))/2
  13. }
  15. func(lQuadraticGA)PerformMutation(_interface{},_int)interface{}{
  16. returnmakeNewEntry()
  17. }
  19. func(lQuadraticGA)Sort(population[]interface{}){
  20. sort.Slice(population,func(i,jint)bool{
  21. returncalculate(population[i].(float64))>calculate(population[j].(float64))
  22. })
  23. }

更奇怪的是，我从来没有提到过这些方法的接口。请记住，因为没有对象，也没有继承。QuadraticGA结构体是一个空白对象，隐式地作为GeneticAlgorithmRunner。每个必需的方法都在括号中绑定到该结构体，就像Java中的“@ override”。现在，结构体和设置需要传递给运行该算法的模块。

  1. settings:=ga.GeneticAlgorithmSettings{
  2. PopulationSize:5,
  3. MutationRate:10,
  4. CrossoverRate:100,
  5. NumGenerations:20,
  6. KeepBestAcrossPopulation:true,
  7. }
  9. best,err:=ga.Run(QuadraticGA{},settings)
  11. iferr!=nil{
  12. println(err)
  13. }else{
  14. fmt.Printf("Best:x:%fy:%f\n",best,calculate(best.(float64)))
  15. }

很简单,对吧?“QuadraticGA {}”只是简单地创建了该结构的一个新实例，其余的则由Run()方法完成。该方法返回搜索结果和发生的任何错误，因为Go不相信try / catch——另一场战争作者采取了严格的设计立场。

现在来计算每个项的性能，以求二次函数求出的二次函数来求出一个新的X值的方法:

  1. funcmakeNewEntry()float64{
  2. returnhighRange*rand.Float64()
  3. }
  5. funccalculate(xfloat64)float64{
  6. returnmath.Pow(x,2)-6*x+2//minimumshouldbeatx=3
  7. }

既然已经为二次实现创建了接口，那么GA本身需要完成:

  1. funcRun(geneticAlgoRunnerGeneticAlgorithmRunner,settingsGeneticAlgorithmSettings)(interface{},error){
  3. population:=geneticAlgoRunner.GenerateInitialPopulation(settings.PopulationSize)
  5. geneticAlgoRunner.Sort(population)
  7. bestSoFar:=population[len(population)-1]
  9. fori:=0;i<settings.NumGenerations;i++{
  11. newPopulation:=make([]interface{},0,settings.PopulationSize)
  13. ifsettings.KeepBestAcrossPopulation{
  14. newPopulation=append(newPopulation,bestSoFar)
  15. }
  17. //performcrossoverswithrandomselection
  18. probabilisticListOfPerformers:=createStochasticProbableListOfIndividuals(population)
  20. newPopIndex:=0
  21. ifsettings.KeepBestAcrossPopulation{
  22. newPopIndex=1
  23. }
  24. for;newPopIndex<settings.PopulationSize;newPopIndex++{
  25. indexSelection1:=rand.Int()%len(probabilisticListOfPerformers)
  26. indexSelection2:=rand.Int()%len(probabilisticListOfPerformers)
  28. //crossover
  29. newIndividual:=geneticAlgoRunner.PerformCrossover(
  30. probabilisticListOfPerformers[indexSelection1],
  31. probabilisticListOfPerformers[indexSelection2],settings.CrossoverRate)
  33. //mutate
  34. ifrand.Intn(101)<settings.MutationRate{
  35. newIndividual=geneticAlgoRunner.PerformMutation(newIndividual)
  36. }
  38. newPopulation=append(newPopulation,newIndividual)
  39. }
  41. population=newPopulation
  43. //sortbyperformance
  44. geneticAlgoRunner.Sort(population)
  46. //keepthebestsofar
  47. bestSoFar=population[len(population)-1]
  49. }
  51. returnbestSoFar,nil
  52. }
  54. funccreateStochasticProbableListOfIndividuals(population[]interface{})[]interface{}{
  56. totalCount,populationLength:=0,len(population)
  57. forj:=0;j<populationLength;j++{
  58. totalCount+=j
  59. }
  61. probableIndividuals:=make([]interface{},0,totalCount)
  62. forindex,individual:=rangepopulation{
  63. fori:=0;i<index;i++{
  64. probableIndividuals=append(probableIndividuals,individual)
  65. }
  66. }
  68. returnprobableIndividuals
  69. }

很像以前，一个新的人口被创造出来，人口的成员将会世代交配，而他们的后代可能携带突变。一个人的表现越好，就越有可能交配。随着时间的推移，算法收敛到***的答案，或者至少是一个相当不错的答案。

那么当它运行时，它返回了什么呢?

  1. Best:x:3.072833y:-6.994695

不坏!由于人口规模只有5、20代，而且输入的范围被限制在[0 100]，这一搜索就钉在了顶点上。

现在，您可能想知道为什么我定义了所有的接口方法来返回“接口{}”。这就像Go和generics一样。没有对象，因此没有对象类型返回，但是没有描述的大小的数据仍然可以在堆栈上传递。这本质上也是这个返回类型的含义:它传递一些已知的和类似的类型的对象。有了这个“泛型”，我就可以将GA移动到它自己的包中，并将相同的代码移到多个不同类型的数据上。

我们有两个输入的3D二次方程，而不是一个二维二次方程的单个输入。接口方法只需要很小的改变:

  1. typeQuad3Dstruct{
  2. x,yfloat64
  3. }
  4. funcmakeNewQuadEntry(newX,newYfloat64)Quad3D{
  5. returnQuad3D{
  6. x:newX,
  7. y:newY,
  8. }
  9. }
  11. funccalculate3D(entryQuad3D)float64{
  12. returnmath.Pow(entry.x,2)-6*entry.x+math.Pow(entry.y,2)-6*entry.y+2
  13. }
  15. typeQuadratic3dGAstruct{
  16. }
  18. func(lQuadratic3dGA)GenerateInitialPopulation(populationSizeint)[]interface{}{
  20. initialPopulation:=make([]interface{},0,populationSize)
  21. fori:=0;i<populationSize;i++{initialPopulation=append(initialPopulation,makeNewQuadEntry(makeNewEntry(),makeNewEntry()))}returninitialPopulation}func(lQuadratic3dGA)PerformCrossover(result1,result2interface{},mutationRateint)interface{}{r1Entry,r2Entry:=result1.(Quad3D),result2.(Quad3D)returnmakeNewQuadEntry((r1Entry.x+r2Entry.x)/2,(r1Entry.y+r2Entry.y)/2,)}func(lQuadratic3dGA)PerformMutation(_interface{})interface{}{returnmakeNewQuadEntry(makeNewEntry(),makeNewEntry())}func(lQuadratic3dGA)Sort(population[]interface{}){sort.Slice(population,func(i,jint)bool{returncalculate3D(population[i].(Quad3D))>calculate3D(population[j].(Quad3D))
  22. })
  23. }
  25. funcquadratic3dMain(){
  26. settings:=ga.GeneticAlgorithmSettings{
  27. PopulationSize:25,
  28. MutationRate:10,
  29. CrossoverRate:100,
  30. NumGenerations:20,
  31. KeepBestAcrossPopulation:true,
  32. }
  34. best,err:=ga.Run(Quadratic3dGA{},settings)
  35. entry:=best.(Quad3D)
  37. iferr!=nil{
  38. println(err)
  39. }else{
  40. fmt.Printf("Best:x:%fy:%fz:%f\n",entry.x,entry.y,calculate3D(entry))
  41. }
  42. }

而不是到处都是float64s，任何地方都可以通过Quad3D的条目;每一个都有一个X和一个Y值。对于创建的每个条目，都使用contructor makeNewQuadEntry创建。Run()方法中的代码都没有更改。

当它运行时，我们得到这个输出:

  1. Best:x:3.891671y:4.554884z:-12.787259

很接近了!

哦，我忘了说走快了!在Java中执行此操作时，即使使用相同的设置，也会有明显的等待时间。在一个相对较小的范围内求解二次方程并不是很复杂，但它对一个人来说是值得注意的。

Go是本地编译的，比如C。当二进制执行时，它似乎马上就吐出一个答案。这里有一个简单的方法来度量每次运行的执行时间:

  1. funcmain(){
  2. beforeQuadTime:=time.Now()
  3. quadraticMain()
  4. afterQuadTime:=time.Since(beforeQuadTime)
  5. fmt.Printf("%d\n",afterQuadTime)
  7. before3dQuadTime:=time.Now()
  8. quadratic3dMain()
  9. after3dQuatTime:=time.Since(before3dQuadTime)
  10. fmt.Printf("%d\n",after3dQuatTime)
  11. }

边注:我能说我很高兴我们是一个开发者社区，让他们从过去的错误中走出来，并把综合的时间模块和包构建成一种语言吗?Java 8 +拥有它们，Python拥有它们，并拥有它们。这使我开心。

现在的输出:

  1. Best:x:3.072833y:-6.994695
  2. 136,876
  3. Best:x:3.891671y:4.554884z:-12.787259
  4. 4,142,778

那“近乎瞬间”的感觉是我想要传达的，现在我们有了很难的数字。136,876看起来很大，但要在纳秒内报告时间。

重申一遍:纳秒。不是几毫秒，我们都习惯了在互联网时代或者其他像Python和Java这样的通用语言;纳秒。1/1,000,000毫秒。

这意味着我们在不到一毫秒的时间里找到了一个使用遗传算法来搜索答案的二次方程的答案。这句话，“该死的瞬间”似乎很合适，不是吗?这包括打印到终端。

那么，要计算更密集的东西呢?在我展示一种寻找好的梦幻足球lineups的方法之前，我在Fanduel上使用。这包括从电子表格中读取数据，制作和过滤lineups，并进行更复杂的交叉和突变。强制寻找***解决方案可能需要超过75,000年(至少使用我当时使用的Python)。

我不需要再检查所有的细节，你可以自己去看代码，但我会在这里显示输出:

  1. typeQuadraticGAstruct{}
  3. func(lQuadraticGA)GenerateInitialPopulation(populationSizeint)[]interface{}{
  4. initialPopulation:=make([]interface{},0,populationSize)
  5. fori:=0;i<populationSize;i++{
  6. initialPopulation=append(initialPopulation,makeNewEntry())
  7. }
  8. returninitialPopulation
  9. }
  11. func(lQuadraticGA)PerformCrossover(result1,result2interface{},_int)interface{}{
  12. return(result1.(float64)+result2.(float64))/2
  13. }
  15. func(lQuadraticGA)PerformMutation(_interface{},_int)interface{}{
  16. returnmakeNewEntry()
  17. }
  19. func(lQuadraticGA)Sort(population[]interface{}){
  20. sort.Slice(population,func(i,jint)bool{
  21. returncalculate(population[i].(float64))>calculate(population[j].(float64))
  22. })
  23. }
0

哦,是的!现在看来这是一个很好的阵容!它只需要16毫秒就能找到。

现在，这个遗传算法可以改进了。与C一样，当将对象传递给方法时，将在堆栈上复制对象(读取数据)。随着对象大小的增长，***不要反复复制它们，而是要在堆中创建它们，并在周围传递指针。目前，我将把它作为未来的工作。

Go也被用coroutines和信道的原生支持编写，利用多个内核来解决一个问题，比过去简单多了，相比于单核时代的其他语言来说，这是一个巨大的优势。我想要增强这个算法来使用这些工具，但这也必须留给以后的工作。

我很享受学习的过程。对于我来说，用组合而不是继承来考虑工程解决方案是很困难的，因为我已经习惯了8年以上的时间，也是我学会编程的方式。但是每种语言和方式都有各自的优点和缺点;每一种语言在我的工具中都是不同的工具。对于任何担心尝试的人，不要。有一个驼峰(更像是一个减速带)，但你很快就会克服它，走上成功之路。

还有一些我喜欢的东西，我喜欢其他语言，主要是一组基本的函数方法来操作数据。我需要一个lambda函数和方法来映射、减少和筛选数据的数组或部分。设计人员反对功能实现的理由是，代码应该总是简单、易于阅读和编写，并且这与for循环是可实现的。我认为，映射、过滤和减少通常更容易读和写，但这是一场已经在肆虐的战争中的争论。

尽管我与一些开发人员的观点存在分歧，以及我必须考虑解决问题的不同方式，但Go真的是一种很好的语言。我鼓励大家在学习一两门语言后再试一试。它很快就成为了***的语言之一，有很多原因可以解释为什么。我期待着在未来更多地使用它。

转载请说明出处
知优网 » Go语言如何实现遗传算法（go语言算法实战）
站长资讯网友投稿帖

站长资讯网友投稿帖

分享到：

相关推荐

发表评论

您需要后才能发表评论