Вы находитесь на странице: 1из 5

CODIGO PROYECTO PYTHON CON SU ALGORITMO METAHEURISTICO

Universidad Agraria Del Ecuador.

Romero Jorge Luis


Ruth Cujilan
Miguel Aguilar
Marlon Montes

Inteligencia Artificial

Ing. Charles Pérez

Noviembre, 2018.

Facultad de Ciencias Agrarias

Escuela de Computación e Informática, Universidad Agraria del Ecuador

Guayaquil-Ecuador

Paralelo, “9SA”
CODIGO EN PYTHON ALGORITMO MEMETICO SIN BUSQUEDA LOCAL.
Genes =
'abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789!"#$%&/()=?¡*¨[]
_:;'
nombre = 'MI_PROFESOR_ES_LO_MAXIMO'
###IMPORTAMOS LAS LIBRERIAS
import datetime
import random
import datetime
import random

random.seed(2)
startTime = datetime.datetime.now()

####### ESTA Funcion para generar de manera aleatoria una muestra de genes Y QUE
SEA NUESTRO PADRE
def generate_parent(length):
genes = [] # Lista donde se almacenan las secuencia aleatoria
while len(genes) < length:
sampleSize = min(length - len(genes), len(Genes))
genes.extend(random.sample(Genes, sampleSize)) # Obtención de la muestra
aleatoria
return ''.join(genes) # Regresamos una cadena
##FUNCIÓN DE ACTITUD
## EN ESTA FUNCION VAMOS A SUMAR 1 SI NUESTRA MUESTAR ALEATORIA COINCIDE
##EN LUGAR Y EN CARACTER DE NUESTRO NOMBRE VAMOS A SUMAR 1
##### ESTA Funcion de optimización, si el muestra aleatoria tiene un caracter
igual a nuestro nombre
def get_fitness(guess):
return sum(1 for expected, actual in zip(nombre, guess) if expected ==
actual)

#FUNCIÓN DE MUTAR
##AQUI SE HACE UNA MUESTRA ALEATORIA Y SE LA VA A AGREGAR PARA QYE
##VAYA ITERANDO EN ESTE PROCESO
#### ESTA Funcion ES para mutar a nuestra cadena original o padre
def mutate(parent):
index = random.randrange(0, len(parent))
childGenes = list(parent)
newGene, alternate = random.sample(Genes, 2)
childGenes[index] = alternate if newGene == childGenes[index] else newGene
return ''.join(childGenes)

## ESTA FUNCION ES PARA MOSTRAR CUAL ES EL PROCESO Y CUANTO TIEMPO TOMA


##### ESTA ES Funcion para imprimir en pantalla los resultados
def display(guess):
timeDiff = datetime.datetime.now() - startTime
fitness = get_fitness(guess)
print('{}\t{}\t{}'.format(guess, fitness, timeDiff))

##INICIALIZAMOS NUESTRAS VARIABLES


##LO PRIMERO QUE HACE AQUI ES INICIALIZAR NUESTRO PADRE
##PARA QUE SE INICIALICE VAMOS A PONER EL NOMBRE, LA LONGITUD DE NUESTRO NOMBRE
COMO NUESTRO BEST PARENT
#DESPUES VAMOS A MEDIR SU FUNCIÓN DE APTITUD OSEA QUE TANTO VA A COINCIDOR CON A
CADENA ORIGINAL Y LUEGO LO VAMOS A MOSTRAR
##
##### AQUI SE Inicializamos nuestros parametros
bestParent = generate_parent(len(nombre))
bestFitness = get_fitness(bestParent)
display(bestParent)
##YA QUE TENEMOS INICILIZADAS NUESTRAS VARIABLES EN ESTA PARTE DEL CODIGO LAS
QUEREMOS METER EN UN CICCLO
## YA QUE ESTA CICLO LO QUE VA A HACER ES MUTAR A NUESTRO PADRES
##### LUEGO Creamos un ciclo para iterar nuestras funciones
##### Hasta obtener nuestro nombre
##GETFINES = ACTITUD
while True:
child = mutate(bestParent)
childFitness = get_fitness(child)
if bestFitness >= childFitness:
continue
display(child)
if childFitness >= len(bestParent):
break
bestFitness = childFitness
bestParent = child

CODIGO EN RUBY ALGORITMO MEMETICO CON BUSQUEDA LOCAL.


def objective_function(vector)
return vector.inject(0.0) {|sum, x| sum + (x ** 2.0)}
end

def random_bitstring(num_bits)
return (0...num_bits).inject(""){|s,i| s<<((rand<0.5) ? "1" : "0")}
end

def decode(bitstring, search_space, bits_per_param)


vector = []
search_space.each_with_index do |bounds, i|
off, sum = i*bits_per_param, 0.0
param = bitstring[off...(off+bits_per_param)].reverse
param.size.times do |j|
sum += ((param[j].chr=='1') ? 1.0 : 0.0) * (2.0 ** j.to_f)
end
min, max = bounds
vector << min + ((max-min)/((2.0**bits_per_param.to_f)-1.0)) * sum
end
return vector
end

def fitness(candidate, search_space, param_bits)


candidate[:vector]=decode(candidate[:bitstring], search_space, param_bits)
candidate[:fitness] = objective_function(candidate[:vector])
end

def binary_tournament(pop)
i, j = rand(pop.size), rand(pop.size)
j = rand(pop.size) while j==i
return (pop[i][:fitness] < pop[j][:fitness]) ? pop[i] : pop[j]
end

def point_mutation(bitstring, rate=1.0/bitstring.size)


child = ""
bitstring.size.times do |i|
bit = bitstring[i].chr
child << ((rand()<rate) ? ((bit=='1') ? "0" : "1") : bit)
end
return child
end
def crossover(parent1, parent2, rate)
return ""+parent1 if rand()>=rate
child = ""
parent1.size.times do |i|
child << ((rand()<0.5) ? parent1[i].chr : parent2[i].chr)
end
return child
end

def reproduce(selected, pop_size, p_cross, p_mut)


children = []
selected.each_with_index do |p1, i|
p2 = (i.modulo(2)==0) ? selected[i+1] : selected[i-1]
p2 = selected[0] if i == selected.size-1
child = {}
child[:bitstring] = crossover(p1[:bitstring], p2[:bitstring], p_cross)
child[:bitstring] = point_mutation(child[:bitstring], p_mut)
children << child
break if children.size >= pop_size
end
return children
end

def bitclimber(child, search_space, p_mut, max_local_gens, bits_per_param)


current = child
max_local_gens.times do
candidate = {}
candidate[:bitstring] = point_mutation(current[:bitstring], p_mut)
fitness(candidate, search_space, bits_per_param)
current = candidate if candidate[:fitness] <= current[:fitness]
end
return current
end

def search(max_gens, search_space, pop_size, p_cross, p_mut, max_local_gens,


p_local, bits_per_param=16)
pop = Array.new(pop_size) do |i|
{:bitstring=>random_bitstring(search_space.size*bits_per_param)}
end
pop.each{|candidate| fitness(candidate, search_space, bits_per_param) }
gen, best = 0, pop.sort{|x,y| x[:fitness] <=> y[:fitness]}.first
max_gens.times do |gen|
selected = Array.new(pop_size){|i| binary_tournament(pop)}
children = reproduce(selected, pop_size, p_cross, p_mut)
children.each{|cand| fitness(cand, search_space, bits_per_param)}
pop = []
children.each do |child|
if rand() < p_local
child = bitclimber(child, search_space, p_mut, max_local_gens,
bits_per_param)
end
pop << child
end
pop.sort!{|x,y| x[:fitness] <=> y[:fitness]}
best = pop.first if pop.first[:fitness] <= best[:fitness]
puts ">gen=#{gen}, f=#{best[:fitness]}, b=#{best[:bitstring]}"
end
return best
end

if _FILE_ == $0
# problem configuration
problem_size = 3
search_space = Array.new(problem_size) {|i| [-5, +5]}
# algorithm configuration
max_gens = 100
pop_size = 100
p_cross = 0.98
p_mut = 1.0/(problem_size*16).to_f
max_local_gens = 20
p_local = 0.5
# execute the algorithm
best = search(max_gens, search_space, pop_size, p_cross, p_mut, max_local_gens,
p_local)
puts "done! Solution: f=#{best[:fitness]}, b=#{best[:bitstring]},
v=#{best[:vector].inspect}"
end