Delete pages

pages/Ejecucion.py

@@ -1,108 +0,0 @@
-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

@@ -1,84 +0,0 @@
-#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

@@ -1,57 +0,0 @@
-#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

@@ -1,28 +0,0 @@
-#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

@@ -1,80 +0,0 @@
-
-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
-
-