Simulación del Problema de la Mochila,

Mediante Algoritmos Genéticos

• En este código, los objetos se representan mediante una lista de tuplas que
contienen su nombre, su peso y su valor. El peso máximo de la mochila se
especifica como una variable separada. Los parámetros del algoritmo
genético se especifican como variables separadas también.
• La función principal resolver_mochila crea una población inicial, evoluciona
la población durante un número fijo de generaciones, y devuelve la mejor
solución encontrada. En cada generación, se muestra información sobre la
mejor solución actual y su peso y valor total. La función devuelve la mejor
solución hasta encontrar que se alcance el peso máximo de la mochila o se
han completado todas las generaciones. Finalmente, se muestra la mejor
solución encontrada, su peso total y su valor total.
import random
objetos = [("objeto 1", 6, 10),
("objeto 2", 5, 8),
("objeto 3", 2, 3),
("objeto 4", 7, 12),
("objeto 5", 4, 6)]
peso_maximo = 15
tam_poblacion = 10
prob_mutacion = 0.1
num_generaciones = 100
def calcular_aptitud(individuo):
peso_total = sum([objetos[i][1] * individuo[i] for i in range(len(objetos))])
valor_total = sum([objetos[i][2] * individuo[i] for i in range(len(objetos))])
if peso_total > peso_maximo:
return 0
else:
return 1 / (valor_total + 1)

La función calcular_aptitud calcula el valor total de los objetos en la mochila

de un individuo y devuelve su inverso como medida de aptitud.
def crear_poblacion_inicial():
poblacion = []
for i in range(tam_poblacion):
individuo = [random.randint(0, 1) for _ in range(len(objetos))]
poblacion.append(individuo)
return poblacion

La función crear_poblacion_inicial crea una población inicial de individuos aleatorios.

 def seleccionar_padres(poblacion):
aptitudes = [calcular_aptitud(individuo) for individuo in poblacion]
total_aptitudes = sum(aptitudes)
ruleta = [aptitud / total_aptitudes for aptitud in aptitudes]
padre1 = random.choices(poblacion, weights=ruleta)[0]
padre2 = random.choices(poblacion, weights=ruleta)[0]
return padre1, padre2

La función seleccionar_padres selecciona dos padres de la población utilizando el método de la ruleta..

def cruzar_padres(padre1, padre2):
punto_corte = random.randint(1, len(objetos) - 1)
hijo = padre1[:punto_corte] + padre2[punto_corte:]
return hijo
 .

def mutar_individuo(individuo):
pos = random.randint(0, len(objetos) - 1)
individuo[pos] = 1 - individuo[pos]

La función mutar_individuo muta un individuo cambiando uno

de sus bits aleatoriamente
 .
def evolucionar_poblacion(poblacion):
nueva_poblacion = []
for i in range(tam_poblacion):
padre1, padre2 = seleccionar_padres(poblacion)
hijo = cruzar_padres(padre1, padre2)
if random.random() < prob_mutacion:
mutar_individuo(hijo)
nueva_poblacion.append(hijo)
return nueva_poblacion

La función evolucionar_población evoluciona la población durante una generación mediante selección, cruza y mutación.
def resolver_mochila():
poblacion = crear_poblacion_inicial()
for i in range(num_generaciones):
poblacion = evolucionar_poblacion(poblacion)
mejor_individuo = max(poblacion, key=calcular_aptitud)
peso_total = sum([objetos[i][1] * mejor_individuo[i] for i in range(len(objetos))])
valor_total = sum([objetos[i][2] * mejor_individuo[i] for i in range(len(objetos))])

print("Generación", i+1, "- Mejor solución:", mejor_individuo,

"- Peso total:", peso_total, "- Valor total:", valor_total)

if peso_total <= peso_maximo:

break
return mejor_individuo
mejor_solucion = resolver_mochila()
peso_total = sum([objetos[i][1] * mejor_solucion[i] for i in range(len(objetos))])
valor_total = sum([objetos[i][2] * mejor_solucion[i] for i in range(len(objetos))])
print("Mejor solución encontrada:", mejor_solucion)
print("Peso total:", peso_total)
print("Valor total:", valor_total)

Generación 1 - Mejor solución: [0, 1, 0, 0, 0] - Peso total: 5 - Valor total: 8

Mejor solución encontrada: [0, 1, 0, 0, 0]
Peso total: 5
Valor total: 8