## 0 Ideas para el concurso
(Compartir en CSDN tan pronto como salgan las preguntas de la competencia)
https://blog.csdn.net/dc_sinor?type=blog
1 Principio del algoritmo de recocido
1.1 Antecedentes físicos
En termodinámica, el fenómeno de recocido se refiere a un fenómeno físico en el que un objeto se enfría gradualmente. Cuanto menor es la temperatura, menor es el estado de energía del objeto; cuando es lo suficientemente bajo, el líquido comienza a condensarse y cristalizar. En el cristalino estado, el estado de energía del sistema es el más bajo. Cuando la naturaleza se enfría lentamente (es decir, se recoce), puede "encontrar" el estado de energía más bajo: la cristalización. Sin embargo, si el proceso es demasiado rápido y rápido, el enfriamiento rápido (también conocido como "enfriamiento") dará como resultado un estado amorfo que no es el estado de energía más bajo.
Como se muestra en la siguiente figura, primero (izquierda) el objeto está en un estado amorfo. Calentamos el sólido a una temperatura suficientemente alta (imagen del medio) y dejamos que se enfríe lentamente o recozca (imagen de la derecha). Cuando se calientan, las partículas internas del sólido se desordenan con el aumento de la temperatura y la energía interna aumenta, pero cuando se enfrían lentamente, las partículas se vuelven gradualmente ordenadas y alcanzan un estado de equilibrio a cada temperatura y finalmente alcanzan el estado fundamental a temperatura ambiente. temperatura, y la energía interna disminuye. es el más pequeño (en este punto el objeto aparece en forma de cristal).
1.2 Modelo Matemático Detrás
Si todavía está confundido acerca del significado físico del recocido, no importa que tengamos una forma más sencilla de entenderlo. Imagínese si ahora tenemos una función como la siguiente, y ahora queremos encontrar la solución óptima (global) de la función. Si se adopta la estrategia Greedy, comience la prueba desde el punto A, y si el valor de la función continúa disminuyendo, el proceso de prueba continuará. Y cuando llegamos al punto B, obviamente nuestro proceso de exploración ha terminado (porque no importa en qué dirección trabajemos duro, el resultado solo se hará más y más grande). Al final, solo podemos encontrar una solución final parcial B.
Según el criterio de Metropolis, la probabilidad de que una partícula tienda a equilibrarse a la temperatura T es exp(-ΔE/(kT)), donde E es la energía interna a la temperatura T, ΔE es su número de cambio y k es la constante de Boltzmann. El criterio de Metropolis a menudo se expresa como
El criterio de Metropolis muestra que cuando la temperatura es T, la probabilidad de un descenso de temperatura con una diferencia de energía de dE es P(dE), expresada como: P(dE) = exp( dE/(kT) ). Donde k es una constante, exp representa el exponente natural y dE<0. Entonces P y T están correlacionados positivamente. Esta fórmula significa: a mayor temperatura, mayor probabilidad de caída de temperatura con una diferencia de energía de dE; a menor temperatura, menor probabilidad de caída de temperatura. Y debido a que dE siempre es menor que 0 (porque el proceso de recocido es un proceso de disminución gradual de la temperatura), entonces dE/kT < 0, entonces el rango de valores de función de P(dE) es (0,1). A medida que la temperatura T disminuye, P(dE) disminuirá gradualmente.
Consideramos un movimiento hacia una solución más pobre como un proceso de salto de temperatura y aceptamos tal movimiento con probabilidad P(dE). Es decir, cuando se usa el recocido sólido para simular el problema de optimización combinatoria, la energía interna E se simula como el valor de la función objetivo f, y la temperatura T se convierte en el parámetro de control t, es decir, el algoritmo de recocido simulado para resolver se obtiene el problema de optimización combinatoria: a partir de la solución inicial i y el control Partiendo del valor inicial del parámetro t, repetir la iteración de "generar una nueva solución→calcular la diferencia de la función objetivo→aceptar o descartar" para la actual La solución actual cuando termina el algoritmo es la solución óptima aproximada obtenida, que se basa en un procedimiento heurístico de búsqueda aleatoria para el método de solución iterativa de Monte Carlo. El proceso de recocido está controlado por el programa de enfriamiento (Cooling Schedule), que incluye el valor inicial t del parámetro de control y su factor de decaimiento Δt, el número de iteraciones L y la condición de parada S para cada valor t.
2 Implementación del algoritmo de recocido
2.1 Proceso del algoritmo
(1) Inicialización: temperatura inicial T (suficientemente grande), estado de solución inicial S (punto de inicio de la iteración del algoritmo), tiempos de iteración L para cada valor T (2) Para k=1, ..., L haga el primero (
3 ) Ir al paso 6:
(3) Generar una nueva solución S′
(4) Calcular el incremento Δt′=C(S′)-C(S), donde C(S) es la función de evaluación
(5) Si Δt′ <0 entonces acepte S' como la nueva solución actual, de lo contrario acepte S' como la nueva solución actual con probabilidad exp(-Δt'/T).(6
) Si se cumple la condición de terminación, genere la solución actual como la solución óptima y terminar el programa.
La condición de terminación generalmente se elige para terminar el algoritmo cuando no se aceptan varias soluciones nuevas consecutivas.
(7) T disminuye gradualmente, y T->0, luego cambia al segundo
2.2 Implementación del algoritmo
import numpy as np
import matplotlib.pyplot as plt
import random
class SA(object):
def __init__(self, interval, tab='min', T_max=10000, T_min=1, iterMax=1000, rate=0.95):
self.interval = interval # 给定状态空间 - 即待求解空间
self.T_max = T_max # 初始退火温度 - 温度上限
self.T_min = T_min # 截止退火温度 - 温度下限
self.iterMax = iterMax # 定温内部迭代次数
self.rate = rate # 退火降温速度
#############################################################
self.x_seed = random.uniform(interval[0], interval[1]) # 解空间内的种子
self.tab = tab.strip() # 求解最大值还是最小值的标签: 'min' - 最小值；'max' - 最大值
#############################################################
self.solve() # 完成主体的求解过程
self.display() # 数据可视化展示
def solve(self):
temp = 'deal_' + self.tab # 采用反射方法提取对应的函数
if hasattr(self, temp):
deal = getattr(self, temp)
else:
exit('>>>tab标签传参有误："min"|"max"<<<')
x1 = self.x_seed
T = self.T_max
while T >= self.T_min:
for i in range(self.iterMax):
f1 = self.func(x1)
delta_x = random.random() * 2 - 1
if x1 + delta_x >= self.interval[0] and x1 + delta_x <= self.interval[1]: # 将随机解束缚在给定状态空间内
x2 = x1 + delta_x
else:
x2 = x1 - delta_x
f2 = self.func(x2)
delta_f = f2 - f1
x1 = deal(x1, x2, delta_f, T)
T *= self.rate
self.x_solu = x1 # 提取最终退火解
def func(self, x): # 状态产生函数 - 即待求解函数
value = np.sin(x**2) * (x**2 - 5*x)
return value
def p_min(self, delta, T): # 计算最小值时，容忍解的状态迁移概率
probability = np.exp(-delta/T)
return probability
def p_max(self, delta, T):
probability = np.exp(delta/T) # 计算最大值时，容忍解的状态迁移概率
return probability
def deal_min(self, x1, x2, delta, T):
if delta < 0: # 更优解
return x2
else: # 容忍解
P = self.p_min(delta, T)
if P > random.random(): return x2
else: return x1
def deal_max(self, x1, x2, delta, T):
if delta > 0: # 更优解
return x2
else: # 容忍解
P = self.p_max(delta, T)
if P > random.random(): return x2
else: return x1
def display(self):
print('seed: {}\nsolution: {}'.format(self.x_seed, self.x_solu))
plt.figure(figsize=(6, 4))
x = np.linspace(self.interval[0], self.interval[1], 300)
y = self.func(x)
plt.plot(x, y, 'g-', label='function')
plt.plot(self.x_seed, self.func(self.x_seed), 'bo', label='seed')
plt.plot(self.x_solu, self.func(self.x_solu), 'r*', label='solution')
plt.title('solution = {}'.format(self.x_solu))
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.savefig('SA.png', dpi=500)
plt.show()
plt.close()
if __name__ == '__main__':
SA([-5, 5], 'max')
alcanzar resultados
