我的遗传算法无法收敛/达到局部最小值
我已经在这个小项目上挣扎了一段时间，非常感谢您的帮助。
我正在尝试构建一种遗传算法，以使用透明形状（三角形）绘制图片，例如：https://chriscummins.cc/s/genetics/，但是我尝试了很多不同的超参数和不同的技术，但我无法确实像上面的网站那样获得任何融合。有时它会运行很长时间，并且仍然会卡在下面的图片中，这似乎已经收敛了，因为没有太多不同的人，但是那里的人并不多！
该算法的工作原理基本上是这样的：
- 人口中的每个人都是一幅在固定数量的三角形的空/黑色画布上的画。
- 通过在个人绘画和目标图像之间进行逐像素平均绝对误差来计算个人健身。
- 我使用比赛选择来选择可以繁殖的个体，以产生下一代的个体。
- 两幅画之间的交叉基本上是随机选择每个父本基因的一半，即他们的三角形。
- 该突变基本上包括对绘画中每个三角形的顶点坐标进行一些更改。
- 我将突变应用于子代。
- 每一代中的佼佼者总是自动前进到下一代。 （精英主义）
我将在下面附加代码，希望它可以理解，并尝试对其进行记录，以使人们更容易地帮助我。
这是我的 Triangle（Gene）类：
class Triangle:
def __init__(self, image):
'''
Parameters
------------
image: PIL.Image
Image where the triangle will be drawn.
This must be passed in order for the random triangle's vertices
to have correct coordinates.
'''
self.max_width, self.max_height = image.size
self.vertices = self.random_polygon()
# RGBA
self.color = Triangle.random_color()
def __str__(self):
return f'Vertices: {[(round(x, 2), round(y, 2)) for (x, y) in self.vertices]} | Color: {self.color}'
def draw(self, draw_object, fill=True) -> None:
'''
Method to draw the polygon using a Pillow ImageDraw.Draw object
Parameters
------------
draw_object: ImageDraw.Draw
Object to draw the image
fill: bool
Whether to fill the polygon or just outline it.
'''
if fill:
draw_object.polygon(self.vertices, fill=self.color)
else:
draw_object.polygon(self.vertices, outline=self.color)
def noise(self, ratio):
'''Generate noise into this object'''
def vertex_noise(vertex):
x, y = vertex
x = random.uniform(max(0.0, x - ratio * x), min(self.max_width, x + ratio * x))
y = random.uniform(max(0.0, y - ratio * y), min(self.max_height, y + ratio * y))
return (x, y)
for i in range(3):
self.vertices[i] = vertex_noise(self.vertices[i])
return self
def random_polygon(self) -> list:
'''Generate a random triangle in the form [(x, y), (x, y), (x, y)]'''
def random_vertex() -> tuple:
x = random.uniform(0.0, self.max_width)
y = random.uniform(0.0, self.max_height)
return (x, y)
return [random_vertex() for _ in range(3)]
@classmethod
def random_color(cls) -> tuple:
'''Generate a random RGBA color tuple'''
def _random(lower, upper):
return random.randint(lower, upper)
return (_random(0, 255), _random(0, 255), _random(0, 255), _random(85, 255))
@classmethod
def collection(cls, size, image) -> list:
'''
Generate collection of triangles
Parameters
------------
size: int
Number of triangles to generate
image: PIL.Image
Image to use for the Triangle constructor.
See help(Triangle) for more info.
Return
--------
collection: list
Collection of polygons.
'''
return [cls(image) for _ in range(size)]
这是绘画（个人）类：
class Painting:
def __init__(self, num_objects, img):
'''
Parameters
------------
num_objects: int
Number of triangles in each painting (this is the DNA size).
img: PIL.Image
Target image that we're trying to approximate
'''
self.polygons = Triangle.collection(num_objects, img)
self.target = img
self.fitness = float('inf')
def __lt__(self, other):
return self.fitness < other.fitness
def __del__(self):
if hasattr(self, 'canvas'):
self.canvas.close()
def fit(self):
'''Fits individual's painted canvas against target image'''
self.paint()
self.fitness = self._error(self.canvas, self.target)
return self
@classmethod
def crossover(cls, indA, indB, ratio):
'''
Reproduces two painting objects and generates a painting child
by randomly choosing genes from each parent in some given proportion.
Parameters
------------
indA: Painting
indB: Painting
ratio: float
Proportion of genes to be taken from the father object.
Return
---------
child: Painting
'''
if len(indA.polygons) != len(indB.polygons):
raise ValueError('Parents\' number of polygons don\'t match.')
if indA.target != indB.target:
raise ValueError('Parents\' target images don\'t match.')
num_objects = len(indA.polygons)
target = indA.target
child = cls(num_objects, target)
indA_ratio = int(ratio * num_objects)
# Crossover Parents' triangles
child.polygons = deepcopy(random.sample(indA.polygons, k=indA_ratio))
child.polygons.extend(deepcopy(random.sample(indB.polygons, k=num_objects-indA_ratio)))
return child
@classmethod
def random_population(cls, size, num_objs, img):
'''Generates a random population of paintings'''
return [cls(num_objs, img) for _ in range(size)]
def mutate(self, mutation_chance, mutation_ratio):
'''
Applies noise to the painting objects' genes, which is basically a "mutation"
Parameters
------------
mutation_chance: float
chance that each gene will be mutated
mutation_ratio: float
intensity of the mutation that will be caused in case it happens.
The noise caused is just a small change in the polygons' vertices coordinates.
See help(Painting.noise()) for more info.
'''
num_objs = len(self.polygons)
rng = random.uniform(0.0, 1.0)
if mutation_chance < rng:
return self
for i in range(num_objs):
rng = random.uniform(0.0, 1.0)
if mutation_chance < rng:
continue
self.polygons[i].noise(mutation_ratio)
return self
def paint(self):
'''Paints genoma into an empty canvas.'''
if hasattr(self, 'canvas'):
self.canvas.close()
# Create white canvas
self.canvas = Image.new(mode='RGB', size=self.target.size)
draw_obj = ImageDraw.Draw(self.canvas, mode='RGBA')
for poly in self.polygons:
poly.draw(draw_obj)
@staticmethod
def _error(canvas, target):
'''Mean Squared Error between PIL Images'''
r_canvas, g_canvas, b_canvas = canvas.split()
r_target, g_target, b_target = target.split()
def mse(a, b):
return np.square(np.subtract(a, b)).mean()
return (mse(r_canvas, r_target) + mse(g_canvas, g_target) + mse(b_canvas, b_target)) / 3.0
最后，这是算法本身的一般流程：
def k_way_tournament_selection(population, number_of_winners, K=3):
selected = []
while len(selected) < number_of_winners:
fighters = random.sample(population, k=min(number_of_winners-len(selected), K))
selected.append(min(fighters))
return selected
EPOCHS = 200
POP_SIZE = 100
DNA_SIZE = 100
MUTATION_CHANCE = 0.01
MUTATION_RATIO = 0.2
SELECTION_RATIO = 0.3
pop = Painting.random_population(POP_SIZE, DNA_SIZE, lisa)
initial = time()
generation_best = []
for ep in range(EPOCHS):
pop = [p.fit() for p in pop]
pop = sorted(pop)
# Save Best
best = pop[0]
generation_best.append(deepcopy(best.canvas))
pop = pop[1:]
# Tournament selection
selected = []
selected = k_way_tournament_selection(pop, int(len(pop) * SELECTION_RATIO))
selected.append(best)
# Reproduce
children = []
while len(children) < POP_SIZE:
indA = random.choice(selected)
indB = random.choice(selected)
cross = Painting.crossover(indA, indB, 0.5)
children.append(cross)
# Mutate
children = [child.mutate(MUTATION_CHANCE, MUTATION_RATIO) for child in children]
children.append(best)
pop = deepcopy(children)
del children
del selected
gc.collect()
t = time()
print(f'EPOCH: {ep} | SIZE: {len(pop)} | ELAPSED: {round(t - initial, 2)}s | BEST: {best.fitness}')
1 个答案:
答案 0 :(得分：0)
好的，所以我找到了主要错误！
问题出在_error函数中。每当PIL图像转换为numpy数组时（在两个2D numpy数组（它们是图像通道）之间调用np.subtract()时，它将转换为np.uint8类型的numpy数组（无符号int 8字节），因为图像在[0-255]范围内，所以很有意义。但是，当使用np.subtract时，如果您得到负值，则它将下溢，并且您的适应度函数将被弄乱。
要解决此问题，只需在执行np.array(channel, np.int32)之前使用np.subtract()投射图像通道
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？