Mostrar puntos en el espacio e ingreso manual de datos

app.py

@@ -3,6 +3,7 @@ import matplotlib.pyplot as plt
 import random
 from mpl_toolkits.mplot3d import Axes3D
 import plotly.graph_objects as go
+import pandas as pd
 
 # Se debe tener instalado plotly, streamlit y matplotlib
 
@@ -194,17 +195,13 @@ def algoritmo_genetico(
     poblacion = generar_poblacion(num_individuos, num_ciudades)
     mejor_solucion_historial = []
     mejor_distancia_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)
         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]
@@ -213,12 +210,9 @@ def algoritmo_genetico(
             hijo1 = mutar(hijo1, probabilidad_mutacion)
             hijo2 = mutar(hijo2, probabilidad_mutacion)
             nueva_poblacion.extend([hijo1, hijo2])
-
         poblacion = nueva_poblacion
-
     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
@@ -247,28 +241,58 @@ def visualizar_proceso_streamlit(
     st.plotly_chart(fig_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")
+    manual_input = st.sidebar.checkbox("Ingresar datos manualmente")
+    # Ingresar datos manualmente o generarlos aleatoriamente (por defecto), además de generar las distancias
+    if manual_input:
+        st.sidebar.subheader("Ingresar coordenadas manualmente:")
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
 
-    num_ciudades = st.sidebar.number_input(
-        "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        coordenadas = []
+        for i in range(num_ciudades):
+            st.sidebar.subheader(f"Coordenadas Ciudad {i + 1}")
+            x = st.sidebar.number_input(
+                f"X Ciudad {i + 1}:", value=0.0, key=f"x_{i}", step=1.0
+            )
+            y = st.sidebar.number_input(
+                f"Y Ciudad {i + 1}:", value=0.0, key=f"y_{i}", step=1.0
+            )
+            z = st.sidebar.number_input(
+                f"Z Ciudad {i + 1}:", value=0.0, key=f"z_{i}", step=1.0
+            )
+            coordenadas.append((x, y, z))
+
+        data = pd.DataFrame(coordenadas, columns=["X", "Y", "Z"])
+        distancias, _ = generar_distancias(num_ciudades)
+    else:
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
+
+        distancias, coordenadas = generar_distancias(num_ciudades)
+        data = pd.DataFrame(coordenadas, columns=["X", "Y", "Z"])
+
+    # Mostrar datos en la interfaz
+    st.write(
+        "Puntos en el espacio tridimensional (X, Y, Z), donde cada punto es una ciudad"
     )
+    st.dataframe(data=data, use_container_width=True)
+
+    # Configuraciones adicionales
     num_generaciones = st.sidebar.slider(
         "Número de Generaciones", min_value=10, max_value=100, value=50
     )
     num_individuos = st.sidebar.slider(
-        "Tamaño de la Población", min_value=10, max_value=100, value=50, step=2
+        "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.01, max_value=0.5, value=0.1
     )
 
-    # 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,
@@ -278,5 +302,6 @@ if __name__ == "__main__":
         distancias,
     )
 
+    # Mostrar resultados
     st.success(f"Mejor solución encontrada: {mejor_solucion}")
     st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")

pages/test.py

@@ -0,0 +1,282 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+import random
+from mpl_toolkits.mplot3d import Axes3D
+import plotly.graph_objects as go
+
+# Se debe tener instalado plotly, streamlit y matplotlib
+
+
+# Función para generar una población inicial aleatoria
+def generar_poblacion(num_individuos, num_ciudades):
+    poblacion = []
+    for _ in range(num_individuos):
+        individuo = list(range(num_ciudades))
+        random.shuffle(individuo)
+        poblacion.append(individuo)
+    return poblacion
+
+
+# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
+def calcular_aptitud(individuo, distancias):
+    distancia_total = 0
+    for i in range(len(individuo) - 1):
+        ciudad_actual = individuo[i]
+        siguiente_ciudad = individuo[i + 1]
+        distancia_total += distancias[ciudad_actual][siguiente_ciudad]
+    distancia_total += distancias[individuo[-1]][individuo[0]]
+    return distancia_total
+
+
+# Función para seleccionar individuos para la reproducción (torneo binario)
+def seleccion_torneo(poblacion, distancias):
+    seleccionados = []
+    for _ in range(len(poblacion)):
+        torneo = random.sample(poblacion, 2)
+        aptitud_torneo = [
+            calcular_aptitud(individuo, distancias) for individuo in torneo
+        ]
+        seleccionado = torneo[aptitud_torneo.index(min(aptitud_torneo))]
+        seleccionados.append(seleccionado)
+    return seleccionados
+
+
+# Función para realizar el cruce de dos padres para producir un hijo
+def cruzar(padre1, padre2):
+    punto_cruce = random.randint(0, len(padre1) - 1)
+    hijo = padre1[:punto_cruce] + [
+        gen for gen in padre2 if gen not in padre1[:punto_cruce]
+    ]
+    return hijo
+
+
+# Función para aplicar mutaciones en la población
+def mutar(individuo, probabilidad_mutacion):
+    if random.random() < probabilidad_mutacion:
+        indices = random.sample(range(len(individuo)), 2)
+        individuo[indices[0]], individuo[indices[1]] = (
+            individuo[indices[1]],
+            individuo[indices[0]],
+        )
+    return individuo
+
+
+# Función para generar distancias aleatorias entre ciudades y sus coordenadas tridimensionales
+def generar_distancias(num_ciudades):
+    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
+    coordenadas = [
+        (random.uniform(0, 100), random.uniform(0, 100), random.uniform(0, 100))
+        for _ in range(num_ciudades)
+    ]
+
+    for i in range(num_ciudades):
+        for j in range(i + 1, num_ciudades):
+            distancias[i][j] = distancias[j][i] = (
+                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
+            )
+
+    return distancias, coordenadas
+
+
+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()
+
+    # 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]
+
+    # Añadir el camino como un trazado 3D interactivo con identificadores
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=x, y=y, z=z, mode="lines+markers", marker=dict(size=5), name="Camino"
+        )
+    )
+
+    # Añadir los puntos de inicio y fin con etiquetas
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=[x[0]],
+            y=[y[0]],
+            z=[z[0]],
+            mode="markers+text",
+            marker=dict(color="green", size=10),
+            name="Inicio",
+            text=[str(camino[0])],
+            textposition="top center",
+        )
+    )
+
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=[x[-1]],
+            y=[y[-1]],
+            z=[z[-1]],
+            mode="markers+text",
+            marker=dict(color="red", size=10),
+            name="Fin",
+            text=[str(camino[-1])],
+            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(
+            go.Scatter3d(
+                x=[xi],
+                y=[yi],
+                z=[zi],
+                mode="markers+text",
+                marker=dict(size=5),
+                text=[str(camino[i + 1])],
+                textposition="top center",
+            )
+        )
+
+    # Configuraciones adicionales
+    fig_camino.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_camino)
+
+
+def algoritmo_genetico(
+    num_generaciones, num_ciudades, num_individuos, probabilidad_mutacion, distancias
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_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)
+        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]
+            hijo1 = cruzar(padre1, padre2)
+            hijo2 = cruzar(padre2, padre1)
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+
+        poblacion = nueva_poblacion
+
+    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 mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
+def visualizar_proceso_streamlit(
+    mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+):
+    generaciones = list(range(len(mejor_distancia_historial)))
+
+    # Crear gráfico interactivo de evolución de la distancia
+    fig_distancia = go.Figure()
+    fig_distancia.add_trace(
+        go.Scatter(x=generaciones, y=mejor_distancia_historial, mode="lines+markers")
+    )
+    fig_distancia.update_layout(
+        title="Evolución de la Distancia en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="Distancia",
+    )
+    st.plotly_chart(fig_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=100, 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
+    )
+
+    # 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,
+    )
+
+    st.success(f"Mejor solución encontrada: {mejor_solucion}")
+    st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")