mejora con la implementación de early stopping

pages/AG_2D.py

@@ -251,6 +251,80 @@ def algoritmo_genetico(
     return mejor_solucion, mejor_distancia
 
 
+def algoritmo_genetico_early_stopping(
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    coordenadas,  # Asegúrate de tener este parámetro
+    probabilidad_cruce,
+    max_generaciones_sin_mejora,
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_historial = []
+    peor = 0
+    fitness_historial = []
+    generaciones_sin_mejora = 0  # Inicializar contador de generaciones sin mejora
+
+    for _ in range(num_generaciones):
+        poblacion = sorted(
+            poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
+        )
+        mejor_individuo = poblacion[0]
+
+        mejor_distancia = calcular_aptitud(mejor_individuo, distancias, coordenadas)
+        # Almacenar el mejor individuo y su distancia en cada generación
+        mejor_solucion_historial.append(mejor_individuo)
+        mejor_distancia_historial.append(mejor_distancia)
+
+        seleccionados = seleccion_torneo(
+            poblacion, distancias, coordenadas
+        )  # Pasa coordenadas aquí
+
+        nueva_poblacion = []
+        for i in range(0, len(seleccionados), 2):
+            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
+            aleatorio_local = random.uniform(0, 1)
+            if aleatorio_local <= probabilidad_cruce:
+                hijo1 = cruzar(padre1, padre2)
+                hijo2 = cruzar(padre2, padre1)
+            else:
+                hijo1, hijo2 = padre1, padre2
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+
+        poblacion = nueva_poblacion
+        if peor < mejor_distancia:
+            peor = mejor_distancia
+            generaciones_sin_mejora = 0  # Reiniciar contador al mejorar
+        else:
+            generaciones_sin_mejora += 1
+
+        # Verificar Early Stopping
+        if generaciones_sin_mejora >= max_generaciones_sin_mejora:
+            st.warning(
+                "Early Stopping: Se detuvo el algoritmo debido a falta de mejora."
+            )
+            break
+
+        fitness_historial.append(fitness(mejor_distancia, peor, len(padre1)))
+    mejor_solucion = poblacion[0]
+    mejor_distancia = calcular_aptitud(mejor_solucion, distancias, coordenadas)
+    # Visualizar el proceso del algoritmo
+    visualizar_proceso_streamlit(
+        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+    )
+    # visualizar el fitness
+    visualizar_fitness_streamlit(fitness_historial)
+    # Visualizar el mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
 def visualizar_fitness_streamlit(fitness_historial):
     generaciones = list(range(len(fitness_historial)))
     fig_fitness = go.Figure()
@@ -323,7 +397,7 @@ if __name__ == "__main__":
     st.dataframe(data=data, use_container_width=True)
 
     # Configuraciones adicionales
-    num_generaciones = st.sidebar.slider(
+    num_generaciones = st.sidebar.number_input(
         "Número de Generaciones", min_value=10, max_value=1000, value=50
     )
     num_individuos = st.sidebar.slider(
@@ -336,17 +410,36 @@ if __name__ == "__main__":
         "Probabilidad de cruce", min_value=0.90, max_value=1.0, value=0.95, step=0.01
     )
     distancias_generadas, coordenadas_generadas = generar_distancias(num_ciudades)
+    checkbox = st.sidebar.checkbox("Early Stopping")
+    if checkbox:
+        max_generaciones_sin_mejora = st.sidebar.number_input(
+            "Limite de generaciones sin mejora",
+            min_value=5,
+            max_value=1000,
+            value=20,
+            step=5,
+        )
+        mejor_solucion, mejor_distancia = algoritmo_genetico_early_stopping(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            coordenadas,
+            probabilidad_cruce,
+            max_generaciones_sin_mejora,
+        )
 
-    # Ejecutar el algoritmo genético
-    mejor_solucion, mejor_distancia = algoritmo_genetico(
-        num_generaciones,
-        num_ciudades,
-        num_individuos,
-        probabilidad_mutacion,
-        distancias,
-        coordenadas,
-        probabilidad_cruce,
-    )
+    else:
+        mejor_solucion, mejor_distancia = algoritmo_genetico(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            coordenadas,
+            probabilidad_cruce,
+        )
 
     # Mostrar resultados
     st.success(f"Mejor solución encontrada: {mejor_solucion}")

pages/AG_3D.py

@@ -220,6 +220,80 @@ def algoritmo_genetico(
     return mejor_solucion, mejor_distancia
 
 
+def algoritmo_genetico_early_stopping(
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    coordenadas,  # Asegúrate de tener este parámetro
+    probabilidad_cruce,
+    max_generaciones_sin_mejora,
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_historial = []
+    peor = 0
+    fitness_historial = []
+    generaciones_sin_mejora = 0  # Inicializar contador de generaciones sin mejora
+
+    for _ in range(num_generaciones):
+        poblacion = sorted(
+            poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
+        )
+        mejor_individuo = poblacion[0]
+
+        mejor_distancia = calcular_aptitud(mejor_individuo, distancias, coordenadas)
+        # Almacenar el mejor individuo y su distancia en cada generación
+        mejor_solucion_historial.append(mejor_individuo)
+        mejor_distancia_historial.append(mejor_distancia)
+
+        seleccionados = seleccion_torneo(
+            poblacion, distancias, coordenadas
+        )  # Pasa coordenadas aquí
+
+        nueva_poblacion = []
+        for i in range(0, len(seleccionados), 2):
+            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
+            aleatorio_local = random.uniform(0, 1)
+            if aleatorio_local <= probabilidad_cruce:
+                hijo1 = cruzar(padre1, padre2)
+                hijo2 = cruzar(padre2, padre1)
+            else:
+                hijo1, hijo2 = padre1, padre2
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+
+        poblacion = nueva_poblacion
+        if peor < mejor_distancia:
+            peor = mejor_distancia
+            generaciones_sin_mejora = 0  # Reiniciar contador al mejorar
+        else:
+            generaciones_sin_mejora += 1
+
+        # Verificar Early Stopping
+        if generaciones_sin_mejora >= max_generaciones_sin_mejora:
+            st.warning(
+                "Early Stopping: Se detuvo el algoritmo debido a falta de mejora."
+            )
+            break
+
+        fitness_historial.append(fitness(mejor_distancia, peor, len(padre1)))
+    mejor_solucion = poblacion[0]
+    mejor_distancia = calcular_aptitud(mejor_solucion, distancias, coordenadas)
+    # Visualizar el proceso del algoritmo
+    visualizar_proceso_streamlit(
+        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+    )
+    # visualizar el fitness
+    visualizar_proceso_fitness_streamlit(fitness_historial)
+    # Visualizar el mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
 def visualizar_proceso_fitness_streamlit(fitness_arreglo):
     generaciones = list(range(len(fitness_arreglo)))
 
@@ -317,7 +391,7 @@ if __name__ == "__main__":
     )
 
     # Configuraciones adicionales
-    num_generaciones = st.sidebar.slider(
+    num_generaciones = st.sidebar.number_input(
         "Número de Generaciones", min_value=10, max_value=1000, value=50
     )
     num_individuos = st.sidebar.slider(
@@ -330,16 +404,36 @@ if __name__ == "__main__":
         "Probabilidad de cruce", min_value=0.9, max_value=0.95, value=0.01, step=0.01
     )
 
-    # Ejecutar el algoritmo genético
-    mejor_solucion, mejor_distancia = algoritmo_genetico(
-        num_generaciones,
-        num_ciudades,
-        num_individuos,
-        probabilidad_mutacion,
-        distancias,
-        coordenadas,
-        probabilidad_cruce,
-    )
+    checkbox = st.sidebar.checkbox("Early Stopping")
+    if checkbox:
+        max_generaciones_sin_mejora = st.sidebar.number_input(
+            "Limite de generaciones sin mejora",
+            min_value=5,
+            max_value=1000,
+            value=20,
+            step=5,
+        )
+        mejor_solucion, mejor_distancia = algoritmo_genetico_early_stopping(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            coordenadas,
+            probabilidad_cruce,
+            max_generaciones_sin_mejora,
+        )
+
+    else:
+        mejor_solucion, mejor_distancia = algoritmo_genetico(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            coordenadas,
+            probabilidad_cruce,
+        )
 
     # Mostrar resultados
     st.success(f"Mejor solución encontrada: {mejor_solucion}")

pages/test.py

@@ -152,7 +152,6 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
             textposition="top center",
         )
     )
-
     fig_camino.add_trace(
         go.Scatter3d(
             x=[x[-1]],
@@ -165,7 +164,6 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
             textposition="top center",
         )
     )
-
     # Añadir etiquetas a los puntos intermedios
     for i, (xi, yi, zi) in enumerate(zip(x[1:-1], y[1:-1], z[1:-1])):
         fig_camino.add_trace(
@@ -185,7 +183,6 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
         scene=dict(aspectmode="cube"),
         title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
     )
-
     # Mostrar el gráfico interactivo en Streamlit
     st.plotly_chart(fig_camino)
 
@@ -207,7 +204,7 @@ def algoritmo_genetico(
     mejor_distancia_historial = []
     peor = 0
     fitness_historial = []
-    for generacion in range(num_generaciones):
+    for _ in range(num_generaciones):
         poblacion = sorted(poblacion, key=lambda x: calcular_aptitud(x, distancias))
         mejor_individuo = poblacion[0]
 
@@ -253,18 +250,16 @@ def algoritmo_genetico(
 
 def visualizar_proceso_fitness_streamlit(fitness_arreglo):
     generaciones = list(range(len(fitness_arreglo)))
-
-    # Crear gráfico interactivo de evolución de la distancia
-    fig_distancia = go.Figure()
-    fig_distancia.add_trace(
+    fig_fitness = go.Figure()
+    fig_fitness.add_trace(
         go.Scatter(x=generaciones, y=fitness_arreglo, mode="lines+markers")
     )
-    fig_distancia.update_layout(
+    fig_fitness.update_layout(
         title="Evolución del fitnesss en Cada Generación",
         xaxis_title="Generación",
         yaxis_title="fitness",
     )
-    st.plotly_chart(fig_distancia)
+    st.plotly_chart(fig_fitness)
 
 
 def visualizar_proceso_streamlit(
@@ -285,17 +280,85 @@ def visualizar_proceso_streamlit(
     st.plotly_chart(fig_distancia)
 
 
+def algoritmo_genetico_early_stopping(
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    probabilidad_cruce,
+    max_generaciones_sin_mejora,
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_historial = []
+    peor = 0
+    fitness_historial = []
+    generaciones_sin_mejora = 0  # Inicializar contador de generaciones sin mejora
+
+    for _ in range(num_generaciones):
+        poblacion = sorted(poblacion, key=lambda x: calcular_aptitud(x, distancias))
+        mejor_individuo = poblacion[0]
+
+        mejor_distancia = calcular_aptitud(mejor_individuo, distancias)
+        # Almacenar el mejor individuo y su distancia en cada generación
+        mejor_solucion_historial.append(mejor_individuo)
+        mejor_distancia_historial.append(mejor_distancia)
+
+        seleccionados = seleccion_torneo(poblacion, distancias)
+
+        nueva_poblacion = []
+        for i in range(0, len(seleccionados), 2):
+            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
+            aleatorio_local = random.uniform(0, 1)
+            if aleatorio_local <= probabilidad_cruce:
+                hijo1 = cruzar(padre1, padre2)
+                hijo2 = cruzar(padre2, padre1)
+            else:
+                hijo1, hijo2 = padre1, padre2
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+
+        poblacion = nueva_poblacion
+        if peor < mejor_distancia:
+            peor = mejor_distancia
+            generaciones_sin_mejora = 0  # Reiniciar contador al mejorar
+        else:
+            generaciones_sin_mejora += 1
+
+        # Verificar Early Stopping
+        if generaciones_sin_mejora >= max_generaciones_sin_mejora:
+            st.warning(
+                "Early Stopping: Se detuvo el algoritmo debido a falta de mejora."
+            )
+            break
+
+        fitness_historial.append(fitness(mejor_distancia, peor, len(padre1)))
+    mejor_solucion = poblacion[0]
+    mejor_distancia = calcular_aptitud(mejor_solucion, distancias)
+
+    # Visualizar el proceso del algoritmo
+    visualizar_proceso_streamlit(
+        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+    )
+    # visualizar el fitness
+    visualizar_proceso_fitness_streamlit(fitness_historial)
+    # Visualizar el mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
 # Ejemplo de uso en Streamlit
 if __name__ == "__main__":
-    # Configurar la interfaz de usuario con Streamlit
     st.title("Algoritmo Genético para el Problema del Viajante")
     st.sidebar.header("Configuración")
-
     num_ciudades = st.sidebar.number_input(
         "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
     )
-    num_generaciones = st.sidebar.slider(
-        "Número de Generaciones", min_value=10, max_value=1000, value=50
+    num_generaciones = st.sidebar.number_input(
+        "Número de Generaciones", min_value=10, max_value=1000, value=50, step=10
     )
     num_individuos = st.sidebar.slider(
         "Tamaño de la Población", min_value=10, max_value=100, value=50, step=2
@@ -307,19 +370,34 @@ if __name__ == "__main__":
     probabilidad_cruce = st.sidebar.slider(
         "Probabilidad de Cruce", min_value=0.9, max_value=1.0, value=0.95, step=0.01
     )
-
     # Generar distancias aleatorias entre las ciudades y sus coordenadas tridimensionales
     distancias, coordenadas = generar_distancias(num_ciudades)
-
-    # Ejecutar el algoritmo genético
-    mejor_solucion, mejor_distancia = algoritmo_genetico(
-        num_generaciones,
-        num_ciudades,
-        num_individuos,
-        probabilidad_mutacion,
-        distancias,
-        probabilidad_cruce,
-    )
-
+    checkbox = st.sidebar.checkbox("Early Stopping")
+    if checkbox:
+        max_generaciones_sin_mejora = st.sidebar.number_input(
+            "Limite de generaciones sin mejora",
+            min_value=5,
+            max_value=1000,
+            value=20,
+            step=5,
+        )
+        mejor_solucion, mejor_distancia = algoritmo_genetico_early_stopping(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            probabilidad_cruce,
+            max_generaciones_sin_mejora,
+        )
+    else:
+        mejor_solucion, mejor_distancia = algoritmo_genetico(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            probabilidad_cruce,
+        )
     st.success(f"Mejor solución encontrada: {mejor_solucion}")
     st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")