Python遗传算法实战：Leanpub.Genetic.Algorithms.with.Python

5星 · 超过95%的资源需积分: 9 112 浏览量更新于2024-07-20 3 收藏 9.34MB PDF 举报

"《Leanpub.Genetic.Algorithms.with.Python.pdf》是一本关于使用Python实现遗传算法的书籍，由Clinton Sheppard撰写。该书详细介绍了如何利用Python进行遗传算法的编程实践，旨在帮助读者理解并掌握这一强大的优化工具。书中包含开源代码，遵循Apache License 2.0许可协议，读者可以在每章的附录或在线获取。作者在创作过程中使用了AsciiDoc进行文本编写，并借助PyCharm IDE进行Python代码的编写和测试。" 《Genetic Algorithms with Python》深入浅出地探讨了遗传算法的概念和应用，这是一种模拟自然选择和遗传机制的计算方法，常用于解决复杂问题的优化。书中首先引入了目标导向的问题解决概念，强调了遗传算法在面对这类问题时的独特优势。在简短的前言之后，作者立即引导读者进入第一个项目，通过实际的编程实践来理解遗传算法的工作原理。遗传算法的核心在于它能够通过模拟生物进化的过程，如选择、交叉和变异，来逐步优化解决方案。在Python环境下，这些过程可以被高效地实现，使得初学者和经验丰富的开发者都能轻松上手。书中可能涵盖了以下关键知识点： 1. **遗传算法的基本概念**：包括适应度函数、种群、选择策略（如轮盘赌选择）、交叉操作（如单点交叉、均匀交叉）和变异操作。 2. **编码与解码**：如何将问题的解决方案表示为二进制串或其他形式的编码，并将解码回实际问题的解决方案。 3. **初始化种群**：随机生成初始解决方案，以及如何设计合适的种群大小。 4. **停止条件**：何时结束算法的运行，例如达到预设的代数限制或适应度阈值。 5. **优化问题的应用**：可能涵盖旅行商问题、组合优化、机器学习参数调优等实例。 6. **Python实现**：使用Python标准库或第三方库（如NumPy、SciPy）来实现遗传算法的各个组件。 7. **代码调试与测试**：如何使用PyCharm IDE进行代码的调试和性能测试。 8. **图形化表示**：可能用到GraphViz生成算法过程的可视化图表，以帮助理解。 9. **许可证与开源代码**：Apache License 2.0的权益和义务，以及如何获取和使用书中提供的开源代码。通过这本书，读者不仅能学习到遗传算法的理论知识，还能获得实际编程的经验，提升在复杂问题求解中的能力。无论你是对算法感兴趣的学生，还是寻找新工具的开发人员，这本书都是一个宝贵的资源，助你在遗传算法的世界中探索前行。

fitness for that guess would be two because two letters match the password. The algorithm might also mutate the last letter

of 'zba' to get 'zbc' and a fitness value of zero. Depending on how the engine is configured it might throw out 'zbc'

immediately, it might keep it in order to maintain genetic diversity, or perhaps it would only keep it if it is better than

some cutoff fitness value when compared with all the other guesses tried by the engine.

We will look more at the password project in the first chapter, and go on to explore a variety of projects to learn different

ways of solving problems with genetic algorithms. However, this book is not about showing you a hand-picked set of

problems you can solve with genetic algorithms. It is about giving you experience making genetic algorithms work for

you using sample projects that you understand and can fall back upon when learning to use other machine learning tools

and techniques, or applying genetic algorithms in your own field of expertise.

Genetic programming with Python

This book uses the Python programming language to explore genetic algorithms. Why Python? Because Python is a low

ceremony, powerful and easy-to-read language whose code can be understood by entry-level programmers. I explain the

occasional Python feature but should you encounter a programming construct you’ve never seen before and can’t intuit,

Python.org and StackOverflow.com are great places to find explanations. If you have experience with another

programming language then you should have no difficulty learning Python by induction while also exploring genetic

algorithms.

example Python syntax

# this is a comment

import math # imports make code from other modules available

# code blocks are initiated by a trailing colon followed by indented lines

class Circle: # define a class

Ê def __init__(self, radius): # constructor with parameter radius

Ê self.radius = radius # store the parameter in a class variable

Ê def get_area(self): # define a function that belongs to the class

Ê return math.pi \

Ê * self.radius \

Ê * self.radius # trailing \ continues the expression on the next line

# code that is not in a class is executed immediately

for i in range(1, 10):

Ê if (i & 1) == 0:

Ê continue

Ê circle = Circle(i) # create an instance

Ê print("A circle with radius {0} has area {1:0.2f}".format(

Ê i, circle.get_area() # `print` writes output to the console

Ê ))

You can run the code above in your browser at https://repl.it/C0uK.

Like blacksmiths, programmers create their own tools. We frequently prototype a solution by using tools we already have

available, not unlike using a pair of pliers to pull a nail. Once we get a good understanding of the problem, however, we

usually restart with a better combination of tools or build a problem-specific one. In this book we will co-evolve a genetic

engine while examining increasingly difficult projects with the engine. Why not just use one of the genetic programming

packages already available for Python like Pyvolution, DEAP, Pyevolve, pySTEP, etc? Because they all have different

Genetic Algorithms with Python | 3

interfaces and options, some of which may not be applicable to a problem, and we’re trying to learn about genetic

algorithms not specific engines. By co-evolving the engine you’ll know exactly how it works so you’ll be able to use its

features effectively to solve the next problem with a genetic algorithm of your own design. The engine will be a by-

product of applying genetic algorithms to the different projects in this book. If you were to co-evolve an engine with a

different set of projects, or even the projects in this book in a different order, you would end up with a different engine.

But, by co-evolving an engine you will gain experience with some of the features available in commonly used packages,

and see how they can affect the performance of your code.

About the author

I am a polyglot programmer with more than 15 years of professional programming experience. Occasionally I step out of

my comfort zone and learn a new language to see what that development experience is like and to keep my skills sharp.

This book grew out of my experiences while learning Python, but it isn’t about Python.

When learning a new programming language, I start with a familiar project and try to learn enough of the new language to

solve it. For me, writing a genetic engine is that familiar project. Why a genetic engine? For one thing, it is a project

where I can explore interesting puzzles, and where even a child’s game like Tic-Tac-Toe can be viewed on a whole new

level. Also, I can select increasingly complex puzzles to drive evolution in the capabilities of the engine. This allows me

to discover the expressiveness of the language, the power of its tool chain, and the size of its development community as I

work through the idiosyncrasies of the language.

About the text

The Python 3.5 code snippets in this book were programmatically extracted from working code files using the tags feature

of AsciiDoc’s include directive. This means they come directly from working code files.

4 | A brief introduction to genetic algorithms

However, one thing we automatically do when playing the game is make use of domain knowledge. For example, after

this sequence:

1? Higher

7? Lower

Why wouldn’t we guess 8, 9, or 10? The reason is, of course, because we know that those numbers are not lower than 7.

Why wouldn’t we guess 1? Because we already tried it. We use our memory of what we’ve tried, our successes and

failures, and our knowledge of the domain, number relationships, to improve our guesses.



When playing a card game inexperienced players build a mental map using the cards in their hand

and those on the table. More experienced players also take advantage of their knowledge of the

problem space, the entire set of cards in the deck. This means they may also keep track of cards that

have not yet been played, and may know they can win the rest of the rounds without having to play

them out. Highly experienced card players also know the probabilities of various winning

combinations. Professionals, who earn their living playing the game, also pay attention to the way

their competitors play… whether they bluff in certain situations, play with their chips when they

think they have a good hand, etc.

A genetic algorithm does not know what lower means. It has no intelligence. It does not learn. It will make the same

mistakes every time. It will only be as good at solving a problem as the person who writes the code. And yet, it can be

used to find solutions to problems that humans would struggle to solve or could not solve at all. How is that possible?

Genetic algorithms use random exploration of the problem space combined with evolutionary processes like mutation and

crossover (exchange of genetic information) to improve guesses. But also, because they have no experience in the problem

domain, they try things a human would never think to try. Thus, a person using a genetic algorithm may learn more about

the problem space and potential solutions. This gives them the ability to make improvements to the algorithm, in a

virtuous cycle.

What can we learn from this?

Technique

The genetic algorithm should make informed guesses.

1.2. Guess the Password

Now let’s see how this applies to guessing a password. Start with a randomly generated initial sequence of letters, then

mutate/change one random letter at a time until the sequence of letters is "Hello World!". Conceptually:

pseudo code

_letters = [a..zA..Z !]

target = "Hello World!"

guess = get 12 random letters from _letters

while guess != target:

Ê index = get random value from [0..length of target]

Ê guess[index] = get 1 random value from _letters

6 | Chapter 1. Hello World!

剩余432页未读，继续阅读

浮舟

粉丝: 627
资源: 381

Python遗传算法实战：Leanpub.Genetic.Algorithms.with.Python

The Implementation of Genetic Algorithm .pdf

genetic algorithm implementation in python

leanpub-starter：Leanpub书籍手稿的初学者回购

Codigos Prontos.rar_GA_algorithms_codes_genetic algorithms

GATS.rar_GATS_algorithms_genetic binary JAVA

Genetic Algorithms with Python

Data.Mining.Using.Grammar.Based.Genetic.Programming.And.Applications[2002]

A_new_Genetic.zip_algorithms

GA.rar_GA_algorithms

实现了Python版遗传算法。_Genetic_Algorithms_Python.zip

最新资源