Ejemplo n.º 1
0
    def test(self):
        """TODO: document this."""

        startTime = datetime.datetime.now()

        vis = Vis()

        def fnDisplay(population, gen, info):

            avg = Fitness(0, 0, 0, 0, 0, score=0)
            for ind in population:
                avg = avg + ind.fitness
            avg = avg // len(population)

            max_fit = avg
            for ind in population:
                if max_fit < ind.fitness:
                    max_fit = ind.fitness

            fitness_diversity = np.std(
                [ind.fitness.score for ind in population])

            gene_diversity = np.std([[allele for allele in ind.genes]
                                     for ind in population],
                                    axis=0)
            max_allele_deviation = np.amax(gene_diversity)

            vis.add_generation(max_fit.score, avg.score,
                               (fitness_diversity, np.mean(gene_diversity)),
                               max_fit.hits, max_fit.misses, info)
            print("Gen " + str(gen) + ":\nAvg Fitness: " + str(avg) +
                  "\nMax Fitness: " + str(max_fit) + "\nGene Diversity: " +
                  str(np.mean(gene_diversity)) + ",  Max Allele Deviation: " +
                  str(max_allele_deviation) + "\nElapsed Time: " +
                  str(datetime.datetime.now() - startTime) + "\n -- ")

        def fnGetFitness(genes):
            return self.get_fitness(genes)

        def fnCreate():
            return self.create_gene()

        muts = generate_mutations()
        genetic.evolve(POPULATION_SIZE, REPRODUCTION_RATES, MUTATION_RATE,
                       fnGetFitness, fnDisplay, muts, fnCreate)

        input("END?")
Ejemplo n.º 2
0
def create_riff_db(initial_pop, options):
    """
    Create a database of riffs to be used by the "composer" to generate it's master pieces
    """

    # Ideally categorise or create new riff_dbs for every scale?
    sys.stderr.write("Creating riff database:  ") 
    tick = ticker()

    g = genetic.evolve(initial_pop, options.pop_limit, options.mutation_rate)
    for i in xrange(options.generations):
        tick.next()
        g.next()
    sys.stderr.write("\n") 
    pop = g.next()

    return pop
Ejemplo n.º 3
0
def create_riff_db(initial_pop, options):
    """
    Create a database of riffs to be used by the "composer" to generate it's master pieces
    """

    # Ideally categorise or create new riff_dbs for every scale?
    sys.stderr.write("Creating riff database:  ")
    tick = ticker()

    g = genetic.evolve(initial_pop, options.pop_limit, options.mutation_rate)
    for i in xrange(options.generations):
        tick.next()
        g.next()
    sys.stderr.write("\n")
    pop = g.next()

    return pop
Ejemplo n.º 4
0
def optimize(npoints, deltap, ipop, ngen, situation):
    """
    Call genetic functions and return the best population.

    npoints: number of values per individual 
    deltap: maximum possible value in an individual's list of values
    ipop: number of initial population
    ngen: number of generations
    situation: circle or travel
    """

    target = 0
    p = genetic.population(ipop, npoints, 0, deltap)
    fitness_history = [
        genetic.grade(p, target, situation, ngen=ngen),
    ]

    for i in xrange(ngen):
        p = genetic.evolve(p, target, situation, i, ngen)
        fitness_history.append(
            genetic.grade(p, target, situation, gen=i, ngen=ngen))

    return p.pop()
Ejemplo n.º 5
0
 def evolve(self, *args, **kwargs):
     self.best = genetic.evolve(*args, **kwargs)
     self.slope = self.best[0]
     self.y_int = self.best[1]
Ejemplo n.º 6
0
Archivo: gp.py Proyecto: ial/genetic
import genetic
#import custom_two_param_score
#import custom_one_param_score
import custom_data_score

#rf = genetic.getrankfunction(custom_two_param_score.buildhiddenset(), custom_two_param_score.scorefunction)
#print genetic.evolve(2, 500, rf, mutationrate = 0.2, breedingrate = 0.1, pexp = 0.7, pnew = 0.1).display()

#rf = genetic.getrankfunction(custom_one_param_score.buildhiddenset(), custom_one_param_score.scorefunction)
#print genetic.evolve(1, 500, rf, mutationrate = 0.2, breedingrate = 0.1, pexp = 0.7, pnew = 0.1).display()

rf = genetic.getrankfunction(custom_data_score.buildhiddenset(), custom_data_score.scorefunction)
print genetic.evolve(1, 500, rf, mutationrate = 0.2, breedingrate = 0.1, pexp = 0.7, pnew = 0.1).display()
Ejemplo n.º 7
0
    population = []
    for track in file:
        notes = track.split()
        track = Track()
        for note in notes:
            track.add_notes(note)
        gene = MusicGene(track)
        population.append(gene)

    return population

if __name__ == "__main__":
    fluidsynth.init(SF2, DRIVER)

    population = import_population("initial.db")
    g = genetic.evolve(population)

    print "Generation #%d"%0
    for i in xrange(len(population)):
        print "Track #%d"%i
        population[i].play()

    for i in xrange(10):
        pdb.set_trace()
        pop = g.next()
        print "Generation #%d"%i
        for i in xrange(len(population)):
            print "Track #%d"%i
            population[i].play()
        
Ejemplo n.º 8
0
start = time.time()
# 1d genetic
for i in range(numOfParam):
    p = g.population(paramRange1[i], i)
    for j in range(1, numOfGen1d + 1):
        print("#########################################################")
        print("#########################################################")
        print("#########################################################")
        print(str(j) + "EVOLUTION" + " FOR PARAM " + str(i))
        print("#########################################################")
        print("#########################################################")
        print("#########################################################")
        f = open("log.txt", "a")
        f.write(str(j) + "EVOLUTION" + " FOR PARAM " + str(i) + "\n")
        f.close()
        p = g.evolve(p, 0)
    paramRange2.append(g.getParamRange(p, i))

f = open("log.txt", "a")
f.write("ParamRange," + str(paramRange2[0]) + "," + str(paramRange2[1]) + "," +
        str(paramRange2[2]) + "," + str(paramRange2[3]) + "," +
        str(paramRange2[4]) + "," + str(paramRange2[5]) + "," +
        str(paramRange2[6]) + "," + str(paramRange2[7]) + "," +
        str(paramRange2[8]) + "," + str(paramRange2[9]) + "," +
        str(paramRange2[10]) + "\n")
f.close()

end = time.time()

f = open("log.txt", "a")
cost = end - start
Ejemplo n.º 9
0
def solve():

    # Create the weighted graph object used for all tests
    graphgen = graphGenerator(10, 20, 100)
    randomgraph = graphgen.wgraph


    # Greedy Algorithm testing
    # Does not require more than one run, as every run yields the same result and approximately the same time
    startgreedy = timeit.default_timer()
    greedyresult = randomgraph.greedytsp(0)
    elapsedgreedy = timeit.default_timer() - startgreedy
    print "Final length of Greedy TSP Tour:", greedyresult[1]
    # print "Final Greedy TSP Algorithm pathlist:", greedyresult[0]


    # Simulated Annealing Algorithm testing
    # Run 100 annealing sessions and return basic statistical
    # analysis of resulting tour lengths and time
    simannealdata = []
    simannealtimedata = []
    simnumruns = 100
    for i in range (simnumruns):
        startanneal = timeit.default_timer()
        graph = SimAnnealingTSPGraph(randomgraph)
        agent = SimAnnealingTSPAgent()
        bestgraph = graph
        count = 0
        shufflecount = 0
        while count < 10:
            if shufflecount >= 1:
                random.shuffle(tspgraph.pathlist)
            tspgraph = agent.anneal(graph)
            if tspgraph.graph.pathlength(tspgraph.pathlist) < bestgraph.graph.pathlength(bestgraph.pathlist):
                bestgraph = tspgraph
            count +=1
            shufflecount +=1
        simelapsed = timeit.default_timer() - startanneal
        simannealdata.append(bestgraph.graph.pathlength(bestgraph.pathlist))
        simannealtimedata.append(simelapsed)
        print "Final length of Simulated Annealing TSP Tour for run",i+1,":", bestgraph.graph.pathlength(bestgraph.pathlist)
        # print "Final Simulated Annealing TSP Algorithm path-list for run",i+1,":", bestgraph.pathlist


    # Genetic Algorithm testing
    # Run 100 instances of the genetic algorithm and return basic
    # statistical analysis of resulting tour lengths and time
    target_score = greedyresult[1]
    geneticdata = []
    genetictimedata = []
    gennumruns = 100
    for j in range (gennumruns):
        startgenetic = timeit.default_timer()
        genetictsp = evolve(randomgraph, target_score)
        print "Final length of Genetic TSP tour for run",j+1,":", genetictsp[1]
        # print "Final Genetic TSP tour path-list for run",j+1,":", genetictsp[0].pathlist
        geneticelapsed = timeit.default_timer() - startgenetic
        geneticdata.append(genetictsp[1])
        genetictimedata.append(geneticelapsed)


    print "========================================================"
    print "================== FINAL RESULTS ======================="
    print "========================================================"

    print "============= GREEDY ALGORITHM RESULTS ================="
    print "Minimum tour length:", greedyresult[1]
    print "Time elapsed:", elapsedgreedy, "seconds"
    print "========================================================"

    print "=========== SIMULATED ANNEALING RESULTS ================"
    print "Out of", simnumruns, "runs:"
    print "Minimum (best) value:", min(simannealdata)
    print "Mean value:", float(sum(simannealdata))/len(simannealdata)
    print "Range:", min(simannealdata), "to", max(simannealdata)
    print "Minimum (best) time:", min(simannealtimedata), "seconds"
    print "Mean time:", float(sum(simannealtimedata))/len(simannealtimedata), "seconds"
    print "Range of times:", min(simannealtimedata), "to", max(simannealtimedata), "seconds"
    print "========================================================"

    print "============== GENETIC ALGORITHM RESULTS ==============="
    print "Out of", gennumruns, "runs:"
    print "Minimum (best) value:", min(geneticdata)
    print "Mean value:", float(sum(geneticdata))/len(geneticdata)
    print "Range:", min(geneticdata), "to", max(geneticdata)
    print "Minimum (best) time:", min(genetictimedata), "seconds"
    print "Mean time:", float(sum(genetictimedata))/len(genetictimedata), "seconds"
    print "Range of times:", min(genetictimedata), "to", max(genetictimedata), "seconds"
    print "========================================================"
Ejemplo n.º 10
0
                    paramRange2[3], paramRange2[4], paramRange2[5],
                    paramRange2[6], paramRange2[7], paramRange2[8],
                    paramRange2[9], paramRange2[10])
for i in range(1, numOfGen2d + 1):
    print("#########################################################")
    print("#############################################################")
    print("#############################################################")
    print(str(i) + "EVOLUTION")
    print("#########################################################")
    print("#############################################################")
    print("#############################################################")
    f = open("log.txt", "a")
    f.write(str(i) + "Evolution\n")
    f.close()
    extra = 2 + int(i / 2)
    p, tmp = g.evolve(p2, 1, extra=extra)
    fitness_history.append(tmp)

print("#############################################################")
print("#############################################################")
print("#############################################################")
print("Grading the Final Population")
f = open("log.txt", "a")
f.write("Grading the Final Population\n")
f.close()
fitness_history.append(g.grade(p, 2 + int(numOfGen2d / 2)))
print("#############################################################")
print("#############################################################")
print("#############################################################")

end = time.time()
Ejemplo n.º 11
0
__author__ = "ARturo"

import genetic as gn

target = 371
p_count = 100
i_length = 5
i_min = 0
i_max = 100
p = gn.population(p_count, i_length, i_min, i_max)
fitness_history = [gn.grade(p, target)]
for x in xrange(100):
    p = gn.evolve(p, target)
    fitness_history.append(gn.grade(p, target))


from operator import add

print reduce(add, p[1], 0)
print reduce(add, p[2], 0)
Ejemplo n.º 12
0
import step_gen as describers
import genetic
from ops import basic_functions as functions

if __name__ == '__main__':

	print('starting')

	hidden_set = describers.build_hidden_set(size=10000)

	# for row in hidden_set[:20]:
	# 	print(row)

	ranker = genetic.get_rank_function(
		hidden_set
		)

	genetic.evolve(
		ranker,
		depth=4,
		pop_size=100,
		functions=functions,
		maxgen=30,
		mutation_rate=.3,
		breeding_rate=.6,
		pexp=.5,
		pnew=.1
		)