mochila 1.0

ga.py

@@ -1,13 +1,38 @@
 import sys
+from typing import List
 
 import numpy as np
 
+from mochila import Mochila
 
-def cal_pop_fitness(equation_inputs, pop):
+
+def cal_pop_fitness(itens: List[Mochila], pop):
     # Cálculo do ‘fitness’ de cada solução na população atual
     # A função ‘fitness’ calcula a soma dos produtos entre cada
     # entrada e seu peso correspondente
-    return np.sum(pop * equation_inputs, axis=1)
+    pontos = get_pontos(itens)
+    pesos = get_pesos(itens)
+
+    soma_pontos = np.sum(pop * pontos, axis=1)
+    soma_pesos = np.sum(pop * pesos, axis=1)
+
+    resultados = []
+
+    for idx, ponto in enumerate(soma_pontos):
+        if soma_pesos[idx] > 30:
+            ponto = 0
+
+        resultados.append(ponto)
+
+    return resultados
+
+
+def get_pontos(itens: List[Mochila]):
+    return [item.ponto for item in itens]
+
+
+def get_pesos(itens: List[Mochila]):
+    return [item.peso for item in itens]
 
 
 def select_mating_pool(pop, fitness, num_parents):
@@ -34,7 +59,7 @@ def crossover(parents, offspring_size):
         # índice do primeiro genitor
         parent1_idx = k % parents.shape[0]
         # índice do segundo genitor
-        parent2_idx = (k+1) % parents.shape[0]
+        parent2_idx = (k + 1) % parents.shape[0]
         # o novo filho terá a primeira parte de seus genes
         # oriunda do primeiro genitor
         offspring[k, 0:crossover_point] = parents[parent1_idx, 0:crossover_point]
@@ -52,7 +77,7 @@ def mutation(offspring_crossover, mutation_rate=0.3):
         if np.random.random() < mutation_rate:
             # O valor aleatório a ser adicionado
             random_idx = np.random.randint(0, offspring_crossover.shape[1])
-            random_value = np.random.uniform(-1.0, 1.0, 1)
-            offspring_crossover[idx, random_idx] = offspring_crossover[idx, random_idx] + random_value
+            random_value = np.random.randint(2)
+            offspring_crossover[idx, random_idx] = random_value
 
     return offspring_crossover

main.py

@@ -1,21 +1,28 @@
 import numpy as np
 import ga
 
+from mochila import Mochila
+
 
 def main():
-    # entradas da equação
-    equation_inputs = [4, -2, 3.5, 5, -11, -4.7]
-    # número de pesos a otimizar
-    num_weights = 6
 
+    saco_de_dormir = Mochila('Saco de dormir', 15, 15)
+    corda = Mochila('Corda', 3, 10)
+    canivete = Mochila('Canivete', 2, 10)
+    tocha = Mochila('Tocha', 5, 5)
+    garrafa = Mochila('Garrafa', 9, 8)
+    comida = Mochila('Comida', 20, 17)
+
+    itens = [saco_de_dormir, corda, canivete, tocha, garrafa, comida]
+
+    num_weights = 6
     sol_per_pop = 8
 
     # população tem sol_per_pop cromossomos com num_weights gens
     pop_size = (sol_per_pop, num_weights)
 
     # População inicial
-    new_population = np.random.uniform(low=-4.0, high=4.0, size=pop_size)
-
+    new_population = np.random.randint(2, size=pop_size)
     # Algoritmo genético
     num_generations = 100
     num_parents_mating = 4
@@ -24,15 +31,15 @@ def main():
         print(f"Geração: {generation}")
 
         # medir o ‘fitness’ de cada cromossomo na população
-        fitness = ga.cal_pop_fitness(equation_inputs, new_population)
+        fitness = ga.cal_pop_fitness(itens, new_population)
 
-        print("Valores de fitness:")
+        print("Valor fitness:")
         print(fitness)
 
         # Selecionar os melhores pais na população para o cruzamento
         parents = ga.select_mating_pool(new_population, fitness, num_parents_mating)
 
-        print("Genitores selecionados:")
+        print("Genitores pais selecionados:")
         print(parents)
 
         # formar a próxima geração usando crossover
@@ -51,14 +58,21 @@ def main():
         new_population[0:parents.shape[0], :] = parents
         new_population[parents.shape[0]:, :] = offspring_mutation
 
-        best_result = np.max(np.sum(new_population*equation_inputs, axis=1))
-        print(f"Melhor resultado depois da geração {generation}: {best_result}")
+        # best_result = np.max(np.sum(new_population*equation_inputs, axis=1))
+        # print(f"Melhor resultado depois da geração {generation}: {best_result}")
 
-    fitness = ga.cal_pop_fitness(equation_inputs, new_population)
-    best_match_idx = np.where(fitness == np.max(fitness))
+    fitness = ga.cal_pop_fitness(itens, new_population)
+    best_match_idx = np.where(fitness == np.max(fitness))[0][0]
 
     print("Melhor solução: ", new_population[best_match_idx, :])
     print("Fitness da melhor solução: ", fitness[best_match_idx])
+    printar_nome_itens_selecionados(best_match_idx, itens, new_population)
+
+
+def printar_nome_itens_selecionados(best_match_idx, itens, new_population):
+    for idx, item in enumerate(itens):
+        if new_population[best_match_idx, idx] == 1:
+            print(item.nome)
 
 
 if __name__ == '__main__':

mochila.py

@@ -0,0 +1,6 @@
+class Mochila:
+
+      def __init__(self, nome, peso, ponto):
+        self.nome = nome
+        self.peso = peso
+        self.ponto = ponto