Cómo usar el algoritmo genético fácilmente

premisa

Basado en la dirección de almacén de código GA-Common

Patrón de arquitectura

Modelo de diseño (versión Pro)

Suplemento de conocimientos básicos

Que es el algoritmo genético

En primer lugar, el algoritmo genético es un algoritmo de optimización que imita la evolución de poblaciones biológicas, logra un método de optimización de modelos complejos mediante iteraciones constantes y puede ser utilizado para resolver problemas de optimización combinatoria.

Algunos conceptos básicos en algoritmo genético

• Población (colección de grupos)
• individual
• Fenotipo
• genotipo

Resumen del proceso de optimización de algoritmos genéticos

Consejos:

• Generalmente hay dos condiciones, incluido el número máximo de iteraciones o alcanzar un cierto grado de aptitud para finalizar
• El proceso de cruce y mutación generalmente está determinado por la tasa de cruce y la tasa de mutación

Problemas que se pueden resolver

• Problema de optimización de parámetros
• Problema de optimización combinatoria

Descripción de codificación

Fundación ambiental

Esta vez se utiliza el almacén de algoritmos genéticos basado en Python GA-Common.

Usar descripción del entorno

python3.6+

Notas de instalación

pip install GA-Common

Ejemplo de uso

Ejemplo 1: aplicación simple

Utilice un algoritmo genético para aproximar un cierto valor superior

import math

from ga import GA, Individual, IndividualMeta, Selector
from ga_codec import CodecPlugin
from ga_cm import CmPlugin
from ga_iter import StopIterPlugin
from ga_generate import GeneratePlugin
from ga_selector import Selector


def get_fitness(individual: Individual):
    val = individual.phenotype.phenotype
    return -math.log(abs(val[0] - 19.1564))  # 逼近19.1564


def run_simple_ga():
    individual_meta = IndividualMeta()
    individual_meta.range_list = [(19, 30)] # 指定参数A的取值范围
    individual_meta.bit_count = [50]  # 指定二进制编码长度

    codec_plugin = CodecPlugin()
    cm_plugin = CmPlugin(0.05, 0.01)  # 指定交叉率和变异率
    stop_iter_plugin = StopIterPlugin(100)  # 指定最大迭代次数
    generate_plugin = GeneratePlugin(50, individual_meta)  # 指定最大种群数量

    selector = Selector(get_fitness)  # 初始化环境选择器

    ga = GA(
        codec_plugin,
        cm_plugin,
        stop_iter_plugin,
        "",
        generate_plugin
    )
    ga.setup_population()  # 初始化种群
    ga.use_selector(selector)  # 适配环境选择器

    vals = []
    for idx, _ in enumerate(ga):
        individuals = ga.population.individuals
        nums = [i.phenotype.phenotype[0] for i in individuals]
        vals.append((idx, sum(nums) / 100))
    

if __name__ == "__main__":
    run_simple_ga()

En este estado, dentro de 100 iteraciones, los parámetros convergerán al valor óptimo.

Ejemplo 2: Optimización de parámetros de funciones cuadráticas

import numpy as np
from ga import GA, IndividualMeta, Individual
from ga_codec import CodecPlugin
from ga_cm import CmPlugin
from ga_generate import GeneratePlugin
from ga_selector import Selector
from ga_iter import StopIterPlugin


x = np.linspace(0, 1, 100)


def get_fitness(individual: Individual):
    phenotypes = individual.phenotype.phenotype

    a, b = phenotypes

    y = a * x ** 2 + b
    mae = np.mean(np.abs(y - x ** 3))

    return 1 / mae


def run_quad():
    individual_meta = IndividualMeta()
    individual_meta.range_list = [(0, 10), (0, 20)]
    individual_meta.bit_count = [100, 100]

    codec_plugin = CodecPlugin()
    cm_plugin = CmPlugin(0.1, 0.1)
    iter_plugin = StopIterPlugin(50)
    generate_plugin = GeneratePlugin(50, individual_meta)

    ga = GA(
        codec_plugin,
        cm_plugin,
        iter_plugin,
        "",
        generate_plugin
    )

    selector = Selector(get_fitness)
    ga.setup_population()
    ga.use_selector(selector)

    best = []
    wrost = []
    fitness = []
    for _ in ga:
        individuals = ga.population.individuals
        individual_pair = [(get_fitness(i), i.phenotype.phenotype) for i in individuals]

        best_a, best_b = max(individual_pair)[1]
        wrost_a, wrost_b = min(individual_pair)[1]

        best.append([best_a, best_b])
        wrost.append([wrost_a, wrost_b])
        fitness.append(sum([i[0] for i in individual_pair]) / len(individuals))


if __name__ == "__main__":
    run_quad()

En el rango de 0 a 1, optimice los parámetros de la función cuadrática y hágalo cercano a la forma de la función cúbica en el rango de 0 a 1.

Básicamente, es seguro que son aproximadamente 10 rondas en el suelo, y el valor de mae se ha reducido a aproximadamente 0,1, y el efecto de optimización es obvio.

Ejemplo 3: optimización de parámetros del modelo SVM

Ejemplo 4: planificación de rutas de navegación

(Continuará...)