Upload 6 files

pages/Ejecucion.py

@@ -0,0 +1,108 @@
+import streamlit as st
+
+from pages.vrp.Origen import Grafo, Vehiculos
+from pages.vrp.Algoritmo_genético import Algoritmo_Genetico
+
+#######################
+## FUNCIONES AUXILIARES
+#######################
+
+def grafar(reparto : list[list[int]]):   
+    
+    result = "digraph { \n"
+
+    for ruta in reparto:
+        result += "Almacén ->"
+        for nodo in ruta:
+            result += str(nodo) + "\n"
+            result += str(nodo) + "->"
+        result += "Almacén \n"
+
+    result += "}" 
+
+    return result
+
+def presentar(reparto : list[list[int]]):
+
+    result = ""
+
+    for i in range(len(reparto)):
+        result += "Camion " + str(i) + ": " + "Almacén -> "
+        for parada in reparto[i]:
+            result += str(parada) + " -> "
+        result += "Almacén \n"
+
+    return result
+
+st.set_page_config(page_title="LupercAI", page_icon= "🚛")
+
+st.title("LupercAI 🚛")
+
+valores_vitales = ["distancias", "demandas_clientes", "capacidad_vehiculos"]
+importado = True
+for valor in valores_vitales: importado = importado and valor in st.session_state
+
+if not importado: 
+    st.warning("Faltan datos", icon="⚠️")
+else:
+    #if "num_nodos" not in st.session_state: st.session_state["num_nodos"] = len(st.session_state["demandas_clientes"])
+    #if "num_vehiculos" not in st.session_state: st.session_state["num_vehiculos"] = len(st.session_state["capacidad_vehiculos"])
+
+    grafo = Grafo(st.session_state["distancias"], st.session_state["demandas_clientes"])
+    vehiculos = Vehiculos(st.session_state["capacidad_vehiculos"])
+
+    if "activar_generaciones" in st.session_state:
+        if st.session_state["activar_generaciones"]:
+            if "alg_genetico" not in st.session_state: st.session_state["alg_genetico"] = Algoritmo_Genetico(tamano_poblacion = st.session_state["tamano_poblacion"], 
+                generaciones = st.session_state["generaciones"], tamano_torneo = st.session_state["tamano_torneo"], 
+                crossover_prob = st.session_state["crossover_prob"], mutation_prob = st.session_state["mutation_prob"])
+        else:
+            if "alg_genetico" not in st.session_state: st.session_state["alg_genetico"] = Algoritmo_Genetico()
+    else:
+        if "alg_genetico" not in st.session_state: st.session_state["alg_genetico"] = Algoritmo_Genetico()
+
+    alg_genetico = st.session_state["alg_genetico"]
+
+    from threading import Thread
+    Thread(target=alg_genetico.generar, args = (grafo, vehiculos)).start()
+    
+
+    #Computación:
+
+    empty_latest_iteration = st.empty()
+    empty_mejor_coste = st.empty()
+
+    st.subheader("Barra de progreso")
+    barra_progreso = st.progress(0)  
+
+    st.subheader("Grafo del mejor recorrido actual")
+    
+    empty_txt = st.empty()
+    
+    empty_grafo = st.empty()
+
+    i = 0
+    while alg_genetico.generacion_actual < alg_genetico.generaciones:
+        #Generación por escrito
+        empty_latest_iteration.write("Generación: " + str(alg_genetico.generacion_actual))
+
+        #Barra de progreso
+        barra_progreso.progress( alg_genetico.generacion_actual/alg_genetico.generaciones)
+
+        #Mejor coste actual (texto)
+        empty_mejor_coste.write("**Mejor coste**: " + str(alg_genetico.mejor_candidato[1]))
+
+        #Descarga de grafo
+        empty_txt.download_button("Mejor recorrido 🔽", presentar(alg_genetico.mejor_candidato[0]), file_name="Mejor reparto - Generacion " + str(alg_genetico.generacion_actual) + ".txt", key=str(i))
+        i += 1
+
+        #Mostrar el grafo
+        empty_grafo.graphviz_chart(grafar(alg_genetico.mejor_candidato[0]))
+
+        
+    #Ultima iteracion
+    empty_latest_iteration.write("Generación: " + str(alg_genetico.generacion_actual))
+    barra_progreso.progress( alg_genetico.generacion_actual/alg_genetico.generaciones)
+    empty_mejor_coste.write("**Mejor coste**: " + str(alg_genetico.mejor_candidato[1]))
+    empty_txt.download_button("Mejor recorrido 🔽", presentar(alg_genetico.mejor_candidato[0]), file_name="Mejor reparto - Generacion " + str(alg_genetico.generacion_actual) + ".txt", key=str(i))
+    empty_grafo.graphviz_chart(grafar(alg_genetico.mejor_candidato[0]))

pages/vrp/Algoritmo_genético.py

@@ -0,0 +1,84 @@
+#VERSIÓN 4: VERSIÓN SEMI-ORIENTADA A OBJETOS
+#(F): A añadir en (F)uturas versiones
+
+### CLASES DEL ALGORITMO ###
+
+from .Reparto import Reparto, division_rutas
+
+class Algoritmo_Genetico:
+    def __init__(self, tamano_poblacion : int = 50, generaciones : int = 100, tamano_torneo : int = 5, 
+                  crossover_prob : float = 0.8, mutation_prob : float = 0.2):
+                
+        #Variables del algoritmo (int)
+        self.tamano_poblacion = tamano_poblacion
+        self.generaciones = generaciones
+        self.tamano_torneo = tamano_torneo
+
+        #Variables del algoritmo (%)
+        self.crossover_prob = crossover_prob
+        self.mutation_prob = mutation_prob
+
+        #Variables en ejecución
+        self.generacion_actual = 0
+        self.mejor_candidato = ([[1,2,3],[4]], float("inf"))
+
+
+    def _poblar(self, grafo, vehiculos):
+        Reparto.grafo = grafo
+        Reparto.vehiculos = vehiculos
+        return crear_poblacion(self)
+
+    def generar(self, grafo, vehiculos): 
+
+        #print("##############\n##EMPEZAMOS               \n##############")
+
+        Poblacion = self._poblar(grafo, vehiculos)
+        poblacion = Poblacion()
+
+        from time import sleep
+
+        for _ in range(self.generaciones):
+            sleep(0.1)
+            poblacion = poblacion.evolucionar()
+            self.generacion_actual = self.generacion_actual + 1
+            self.mejor_candidato = (division_rutas(poblacion.poblacion[0]), poblacion.poblacion[0].coste)
+
+        from .Evolucion import mejor_individuo
+
+        return mejor_individuo(poblacion.poblacion)
+    
+def crear_poblacion(alg_genetico : Algoritmo_Genetico): #quizas haga falta , clase_Reparto : type = Reparto
+    import random    
+
+    from .Evolucion import Evolucion
+
+    class Poblacion:
+        def __init__(self, poblacion : list[Reparto] = [Reparto()]*alg_genetico.tamano_poblacion):
+            self.poblacion = poblacion
+
+        def evolucionar(self):
+            new_poblacion = [Evolucion.elitismo(self.poblacion)]
+
+            for _ in range(alg_genetico.tamano_poblacion - 1):
+                new_poblacion += [self._evolucionar_individuo()]
+
+            return Poblacion(new_poblacion)
+
+        def _evolucionar_individuo(self):              
+            parent1 = Evolucion.torneo(self.poblacion, alg_genetico.tamano_torneo)            
+
+            child = parent1
+
+            if random.random() < alg_genetico.crossover_prob: #Cruce %
+                parent2 = Evolucion.torneo(self.poblacion, alg_genetico.tamano_torneo)     
+                child = Evolucion.crossover(parent1, parent2)
+            if random.random() < alg_genetico.mutation_prob: #Mutación %
+                child = Evolucion.mutate(child)
+
+            return child
+
+    return Poblacion
+
+
+
+

pages/vrp/Evolucion.py

@@ -0,0 +1,57 @@
+#VERSIÓN 4: VERSIÓN SEMI-ORIENTADA A OBJETOS
+#(F): A añadir en (F)uturas versiones
+
+### FUNCIONES AUXILIARES ###
+
+import random
+
+from .Reparto import Reparto
+
+
+def mejor_individuo(list_individuos : list[Reparto]) -> Reparto: #paralelizable
+        mejor_individuo = list_individuos[0]
+        for individuo in list_individuos[1:]: 
+            mejor_individuo = individuo if individuo.coste < mejor_individuo.coste else mejor_individuo
+        #print("mejor_individuo: ", mejor_individuo.ruta, mejor_individuo.coste)
+        return mejor_individuo
+
+class Evolucion:              
+
+    @staticmethod
+    def elitismo(poblacion : list[Reparto]) -> Reparto: #mejor ruta de la poblacion
+        return mejor_individuo(poblacion)
+
+    @staticmethod
+    def torneo(poblacion : list[Reparto], tamano_torneo) -> list[Reparto]: #mejor ruta de una parte de la poblacion
+        selected_individuos = random.sample(poblacion, tamano_torneo)
+        return mejor_individuo(selected_individuos)
+
+    @staticmethod
+    def mutate(ruta : Reparto) -> Reparto: #intercambia dos posiciones en la ruta
+        idx1, idx2 = random.sample(range(Reparto.grafo.num_nodos + Reparto.vehiculos.num_vehiculos - 2), 2) 
+        lista = ruta.ruta.copy()
+        lista[idx1], lista[idx2] = lista[idx2], lista[idx1]
+        return Reparto(lista)
+
+    @staticmethod
+    def crossover(parent1 : Reparto, parent2 : Reparto) -> Reparto: #cruza dos rutas, pegando un cacho de la primera en la segunda
+        num_total = Reparto.grafo.num_nodos + Reparto.vehiculos.num_vehiculos - 2
+                                                                                        #-1 por el Almacén
+                                                                                        #-1 porque si hay n vehiculos, solo añadimos n-1 simbolos
+
+        start = random.randint(0, num_total - 1) #random.randint(a, b) toma un número entero al azar entre [a,b], no entre [a,b)
+        end = random.randint(start, num_total - 1)
+
+        child = [None] * num_total
+
+        for i in range(start, end+1):
+            child[i] = parent1.ruta[i]
+        remaining = [item for item in parent2.ruta if item not in child]
+        remaining_index = 0
+        for i in range(num_total):
+            if child[i] == None:
+                child[i] = remaining[remaining_index]
+                remaining_index += 1
+
+        return Reparto(child)
+

pages/vrp/Origen.py

@@ -0,0 +1,28 @@
+#VERSIÓN 5: VRP
+#(F): A añadir en (F)uturas versiones
+
+### CLASES DEL GRAFO ###
+class Grafo:
+    def __init__(self, distancias: list[list[float]], demandas_clientes: list[float], num_nodos: int = None):
+        if num_nodos == None:  num_nodos = len(distancias)
+
+        if len(demandas_clientes) == num_nodos:
+            self.num_nodos = num_nodos
+            self.distancias = distancias
+            self.demandas_clientes = demandas_clientes ##El almacén ya está incluido
+        else:
+            raise IndexError("Las demandas no son igual al número de clientes")
+
+class Vehiculos:
+    def __init__(self, capacidad_vehiculos: list[float], num_vehiculos: int = None):
+        if num_vehiculos == None:  num_vehiculos = len(capacidad_vehiculos)
+
+        if len(capacidad_vehiculos) == num_vehiculos or num_vehiculos == None:
+            self.num_vehiculos = num_vehiculos            
+            self.capacidad_vehiculos = sorted(capacidad_vehiculos)
+        else:
+            raise IndexError("Las capacidades no son igual al número de vehiculos")
+        
+
+        
+    

pages/vrp/Reparto.py

@@ -0,0 +1,80 @@
+
+from .Origen import Grafo, Vehiculos
+
+class Reparto:
+        grafo = None
+        vehiculos = None
+
+        def __init__(self, ruta = None):
+            if type(self.grafo) == Grafo and type(self.vehiculos) == Vehiculos:
+                if ruta == None:   
+                    ruta = list(range(-self.vehiculos.num_vehiculos + 1, self.grafo.num_nodos))
+                    ruta.remove(0)
+
+                self.ruta = ruta
+                self.coste = self._coste()
+
+        def __str__(self):
+            return str((self.ruta,self.coste))
+
+        def _coste(self):                        
+            # Función de aptitud para evaluar la calidad de las soluciones
+            (distancia_total , demanda_total) = (0,0)
+            capacidades_actual = self.vehiculos.capacidad_vehiculos.copy()
+
+            rutas = division_rutas(self)
+
+            i = 1
+            for ruta in rutas:
+                distancia_total += coste_1ruta(ruta)
+                (demanda_actual, capacidades_actual) = capacidad_1ruta(ruta, capacidades_actual)
+                demanda_total += demanda_actual
+                i += 1
+
+            if demanda_total < float('inf'):
+                return distancia_total
+            else:
+                return float('inf')
+
+        
+def coste_1ruta(ruta : list[int]) -> int: #ruta = [1,2,3] sin #
+    recorrido = [0] + ruta + [0] #recorrido = [0,1,2,3,0]
+    
+    distacia_total = 0
+        
+    prev_nodo = 0
+    for nodo in recorrido[1:]:   
+        
+        distacia_total += Reparto.grafo.distancias[prev_nodo][nodo]
+        prev_nodo = nodo
+            
+    return distacia_total
+
+def capacidad_1ruta(ruta : list[int], capacidades_actual : list[int]) -> int: #ruta = [1,2,3] sin #
+    demanda_total = 0
+        
+    for nodo in ruta:        
+        demanda_total += Reparto.grafo.demandas_clientes[nodo]
+
+    if demanda_total <= capacidades_actual[-1]:
+        indice_capacidad = 0
+        while demanda_total > capacidades_actual[indice_capacidad]:
+            indice_capacidad += 1
+        capacidades_actual.pop(indice_capacidad)
+        return (demanda_total, capacidades_actual)
+    else:
+        return (float('inf'), capacidades_actual)
+    
+def division_rutas(reparto : Reparto) -> list[list[int]]:
+    result = []
+    ruta = []
+    for nodo in reparto.ruta:
+        if nodo >= 0:
+            ruta += [nodo]
+        else:
+            result += [ruta.copy()]
+            ruta = []
+    result += [ruta.copy()]
+    return result
+
+