implementación del fitness y probabilidad de cruce

pages/AG_2D.py

@@ -127,22 +127,27 @@ def visualizar_camino(camino, coordenadas, mejor_distancia):
 def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     fig_camino = go.Figure()
 
-    # Añadir el camino como un trazado 2D interactivo
-    x = [coordenadas[i][0] for i in camino]
-    y = [coordenadas[i][1] for i in camino]
+    # Ordenar las coordenadas de acuerdo con el camino
+    ordenado_x = [coordenadas[i][0] for i in camino]
+    ordenado_y = [coordenadas[i][1] for i in camino]
 
-    # Añadir el camino como un trazado 2D interactivo con identificadores
+    # Añadir el camino como un trazado 2D interactivo sin markers
     fig_camino.add_trace(
-        go.Scatter(x=x, y=y, mode="lines+markers", marker=dict(size=5), name="Camino")
+        go.Scatter(
+            x=ordenado_x,
+            y=ordenado_y,
+            mode="lines",
+            name="Camino",
+        )
     )
 
     # Añadir los puntos de inicio y fin con etiquetas
     fig_camino.add_trace(
         go.Scatter(
-            x=[x[0]],
-            y=[y[0]],
+            x=[ordenado_x[0]],
+            y=[ordenado_y[0]],
             mode="markers+text",
-            marker=dict(color="green", size=10),
+            marker=dict(color="green", size=15),
             name="Inicio",
             text=[str(camino[0])],
             textposition="top center",
@@ -151,10 +156,10 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
 
     fig_camino.add_trace(
         go.Scatter(
-            x=[x[-1]],
-            y=[y[-1]],
+            x=[ordenado_x[-1]],
+            y=[ordenado_y[-1]],
             mode="markers+text",
-            marker=dict(color="red", size=10),
+            marker=dict(color="red", size=15),
             name="Fin",
             text=[str(camino[-1])],
             textposition="top center",
@@ -162,15 +167,16 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     )
 
     # Añadir etiquetas a los puntos intermedios
-    for i, (xi, yi) in enumerate(zip(x[1:-1], y[1:-1])):
+    for i, (xi, yi) in enumerate(zip(ordenado_x[1:-1], ordenado_y[1:-1])):
         fig_camino.add_trace(
             go.Scatter(
                 x=[xi],
                 y=[yi],
                 mode="markers+text",
-                marker=dict(size=5),
+                marker=dict(size=3),
                 text=[str(camino[i + 1])],
                 textposition="top center",
+                showlegend=False,
             )
         )
 
@@ -183,6 +189,15 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     st.plotly_chart(fig_camino)
 
 
+# funcion para fitness
+def fitness(distancia, maxima_distancia, tamCromosoma):
+    return (
+        0
+        if distancia * tamCromosoma == 0
+        else 1 - ((distancia) / (maxima_distancia * tamCromosoma))
+    )
+
+
 def algoritmo_genetico(
     num_generaciones,
     num_ciudades,
@@ -190,11 +205,14 @@ def algoritmo_genetico(
     probabilidad_mutacion,
     distancias,
     coordenadas,
+    probabilidad_cruce,
 ):
     poblacion = generar_poblacion(num_individuos, num_ciudades)
     mejor_solucion_historial = []
     mejor_distancia_historial = []
-    for generacion in range(num_generaciones):
+    peor = 0
+    fitness_historial = []
+    for _ in range(num_generaciones):
         poblacion = sorted(
             poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
         )
@@ -206,24 +224,47 @@ def algoritmo_genetico(
         nueva_poblacion = []
         for i in range(0, len(seleccionados), 2):
             padre1, padre2 = seleccionados[i], seleccionados[i + 1]
-            hijo1 = cruzar(padre1, padre2)
-            hijo2 = cruzar(padre2, padre1)
+            aleatorio_cruce = random.uniform(0, 1)
+            if aleatorio_cruce < 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
+        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()
+    fig_fitness.add_trace(
+        go.Scatter(x=generaciones, y=fitness_historial, mode="lines+markers")
+    )
+    fig_fitness.update_layout(
+        title="Evolución del fitness en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="Fitness",
+    )
+    st.plotly_chart(fig_fitness)
+
+
 def visualizar_proceso_streamlit(
     mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
 ):
@@ -242,6 +283,7 @@ def visualizar_proceso_streamlit(
     st.plotly_chart(fig_distancia)
 
 
+#####################
 if __name__ == "__main__":
     st.title("Algoritmo Genético para el Problema del Viajante")
     st.sidebar.header("Configuración")
@@ -288,8 +330,12 @@ if __name__ == "__main__":
         "Tamaño de la Población ($par$)", min_value=10, max_value=500, value=50, step=2
     )
     probabilidad_mutacion = st.sidebar.slider(
-        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1
+        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1, step=0.01
+    )
+    probabilidad_cruce = st.sidebar.slider(
+        "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)
 
     # Ejecutar el algoritmo genético
     mejor_solucion, mejor_distancia = algoritmo_genetico(
@@ -299,6 +345,7 @@ if __name__ == "__main__":
         probabilidad_mutacion,
         distancias,
         coordenadas,
+        probabilidad_cruce,
     )
 
     # Mostrar resultados

pages/AG_3D.py

@@ -19,7 +19,6 @@ def generar_poblacion(num_individuos, num_ciudades):
     return poblacion
 
 
-# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
 # Función para evaluar la aptitud de un individuo (distancia total del recorrido)
 def calcular_aptitud(individuo, distancias, coordenadas):
     distancia_total = 0
@@ -88,50 +87,6 @@ def generar_distancias(num_ciudades):
     return distancias
 
 
-def visualizar_camino(camino, coordenadas, mejor_distancia):
-    fig = go.Figure()
-
-    # Añadir el camino como un trazado 3D interactivo
-    x = [coordenadas[i][0] for i in camino]
-    y = [coordenadas[i][1] for i in camino]
-    z = [coordenadas[i][2] for i in camino]
-
-    fig.add_trace(go.Scatter3d(x=x, y=y, z=z, mode="lines+markers", name="Camino"))
-
-    # Añadir el punto de inicio
-    fig.add_trace(
-        go.Scatter3d(
-            x=[x[0]],
-            y=[y[0]],
-            z=[z[0]],
-            mode="markers",
-            marker=dict(color="green", size=10),
-            name="Inicio",
-        )
-    )
-
-    # Añadir el punto de fin
-    fig.add_trace(
-        go.Scatter3d(
-            x=[x[-1]],
-            y=[y[-1]],
-            z=[z[-1]],
-            mode="markers",
-            marker=dict(color="red", size=10),
-            name="Fin",
-        )
-    )
-
-    # Configuraciones adicionales
-    fig.update_layout(
-        scene=dict(aspectmode="cube"),
-        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
-    )
-
-    # Mostrar el gráfico interactivo en Streamlit
-    st.plotly_chart(fig)
-
-
 def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     fig_camino = go.Figure()
 
@@ -185,6 +140,7 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
                 marker=dict(size=5),
                 text=[str(camino[i + 1])],
                 textposition="top center",
+                showlegend=False,
             )
         )
 
@@ -198,7 +154,12 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     st.plotly_chart(fig_camino)
 
 
-# ...
+def fitness(distancia, maxima_distancia, tamCromosoma):
+    return (
+        0
+        if distancia * tamCromosoma == 0
+        else 1 - ((distancia) / (maxima_distancia * tamCromosoma))
+    )
 
 
 def algoritmo_genetico(
@@ -208,10 +169,13 @@ def algoritmo_genetico(
     probabilidad_mutacion,
     distancias,
     coordenadas,
+    probabilidad_cruce,
 ):
     poblacion = generar_poblacion(num_individuos, num_ciudades)
     mejor_solucion_historial = []
     mejor_distancia_historial = []
+    peor = 0
+    fitness_historial = []
     for generacion in range(num_generaciones):
         poblacion = sorted(
             poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
@@ -224,24 +188,55 @@ def algoritmo_genetico(
         nueva_poblacion = []
         for i in range(0, len(seleccionados), 2):
             padre1, padre2 = seleccionados[i], seleccionados[i + 1]
-            hijo1 = cruzar(padre1, padre2)
-            hijo2 = cruzar(padre2, padre1)
+            aleatorio_cruce = random.uniform(0, 1)
+            if aleatorio_cruce < 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
+        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)))
+
+    # Crear gráfico interactivo de evolución de la distancia
+    fig_distancia = go.Figure()
+    fig_distancia.add_trace(
+        go.Scatter(x=generaciones, y=fitness_arreglo, mode="lines+markers")
+    )
+    fig_distancia.update_layout(
+        title="Evolución del fitnesss en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="fitness",
+    )
+    st.plotly_chart(fig_distancia)
+
+
 def visualizar_proceso_streamlit(
     mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
 ):
@@ -330,7 +325,10 @@ if __name__ == "__main__":
         "Tamaño de la Población ($par$)", min_value=10, max_value=100, value=50, step=2
     )
     probabilidad_mutacion = st.sidebar.slider(
-        "Probabilidad de Mutación", min_value=0.001, max_value=0.5, value=0.01
+        "Probabilidad de Mutación", min_value=0.01, max_value=0.1, value=0.01
+    )
+    probabilidad_cruce = st.sidebar.slider(
+        "Probabilidad de cruce", min_value=0.9, max_value=0.95, value=0.01, step=0.01
     )
 
     # Ejecutar el algoritmo genético
@@ -340,7 +338,8 @@ if __name__ == "__main__":
         num_individuos,
         probabilidad_mutacion,
         distancias,
-        coordenadas,  # Se añade este argumento
+        coordenadas,
+        probabilidad_cruce,
     )
 
     # Mostrar resultados

pages/test.py

@@ -6,6 +6,8 @@ import plotly.graph_objects as go
 
 # Se debe tener instalado plotly, streamlit y matplotlib
 
+st.set_page_config(layout="centered", page_title="Sección de pruebas", page_icon="🧬")
+
 
 # Función para generar una población inicial aleatoria
 def generar_poblacion(num_individuos, num_ciudades):
@@ -188,16 +190,27 @@ def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
     st.plotly_chart(fig_camino)
 
 
+def fitness(distancia, maxima_distancia, tamCromosoma):
+    return 1 - ((distancia) / (maxima_distancia * tamCromosoma))
+
+
 def algoritmo_genetico(
-    num_generaciones, num_ciudades, num_individuos, probabilidad_mutacion, distancias
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    probabilidad_cruce,
 ):
     poblacion = generar_poblacion(num_individuos, num_ciudades)
     mejor_solucion_historial = []
     mejor_distancia_historial = []
-
+    peor = 0
+    fitness_historial = []
     for generacion 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)
@@ -208,14 +221,21 @@ def algoritmo_genetico(
         nueva_poblacion = []
         for i in range(0, len(seleccionados), 2):
             padre1, padre2 = seleccionados[i], seleccionados[i + 1]
-            hijo1 = cruzar(padre1, padre2)
-            hijo2 = cruzar(padre2, padre1)
+            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
+        # print(peor,fitness(mejor_distancia,peor,len(padre1)))
+        fitness_historial.append(fitness(mejor_distancia, peor, len(padre1)))
     mejor_solucion = poblacion[0]
     mejor_distancia = calcular_aptitud(mejor_solucion, distancias)
 
@@ -223,12 +243,30 @@ def algoritmo_genetico(
     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)))
+
+    # Crear gráfico interactivo de evolución de la distancia
+    fig_distancia = go.Figure()
+    fig_distancia.add_trace(
+        go.Scatter(x=generaciones, y=fitness_arreglo, mode="lines+markers")
+    )
+    fig_distancia.update_layout(
+        title="Evolución del fitnesss en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="fitness",
+    )
+    st.plotly_chart(fig_distancia)
+
+
 def visualizar_proceso_streamlit(
     mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
 ):
@@ -257,13 +295,17 @@ if __name__ == "__main__":
         "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=100, value=50
+        "Número de Generaciones", min_value=10, max_value=1000, value=50
     )
     num_individuos = st.sidebar.slider(
         "Tamaño de la Población", min_value=10, max_value=100, value=50, step=2
     )
     probabilidad_mutacion = st.sidebar.slider(
-        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1
+        "Probabilidad de Mutación", min_value=0.01, max_value=0.1, value=0.01
+    )
+
+    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
@@ -276,6 +318,7 @@ if __name__ == "__main__":
         num_individuos,
         probabilidad_mutacion,
         distancias,
+        probabilidad_cruce,
     )
 
     st.success(f"Mejor solución encontrada: {mejor_solucion}")

requirements.txt

@@ -1,3 +1,3 @@
 plotly
 streamlit
-matplotlib
+matplotlib