Ejemplo n.º 1
0
    def _make_alleles(self): 
        """ Returns a GAllelle.Galleles instance with alleles corresponding to 
        the parameters specified by the user"""
        
        alleles = GAllele.GAlleles()
        count = 0
        for param in self.get_parameters().values():
            allele = None
            count += 1
            val = param.evaluate() #now grab the value 
            low = param.low
            high = param.high
      
            metadata = param.get_metadata()[0][1]
            
            #then it's a float or an int, or a member of an array
            if ('low' in metadata or 'high' in metadata) or array_test.search(param.targets[0]): 
                if isinstance(val, real_types):                
                    #some kind of float
                    allele = GAllele.GAlleleRange(begin=low, end=high, real=True)
                #some kind of int    
                if isinstance(val, int_types):
                    allele = GAllele.GAlleleRange(begin=low, end=high, real=False)
                    
            elif "values" in metadata and isinstance(metadata['values'], iterable_types):
                allele = GAllele.GAlleleList(metadata['values'])

            if allele:
                alleles.add(allele)
            else: 
                self.raise_exception("%s is not a float, int, or enumerated \
                datatype. Only these 3 types are allowed"%(param.targets[0]),ValueError)
        
        self.count = count
        return alleles
Ejemplo n.º 2
0
 def test_createAlleleRange(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     self.assertEqual(_allelerange.beginEnd, [(10, 20)])
     self.assertEqual(_allelerange.minimum, 10)
     self.assertEqual(_allelerange.maximum, 20)
     _allelerange = GAllele.GAlleleRange(1.0, 2.0, real=True)
     self.assertEqual(_allelerange.real, True)
Ejemplo n.º 3
0
def run_ga(fast):
    """Initialize and run the genetic algorithms."""
    alleles = GAllele.GAlleles()  # create list of all alleles
    alleles.add(GAllele.GAlleleRange(1, 1000))  # range for the number of days
    alleles.add(GAllele.GAlleleRange(1, 20))  # range for hidden nodes
    alleles.add(GAllele.GAlleleRange(1, 10))  # number of epochs
    alleles.add(GAllele.GAlleleList([True, False]))  # bias
    alleles.add(
        GAllele.GAlleleList([float(x * Decimal("0.1"))
                             for x in range(0, 10)]))  # momentum
    alleles.add(GAllele.GAlleleList([TanhLayer, SigmoidLayer]))  # tanh/sigmoid

    genome = G1DList.G1DList(len(alleles))
    genome.setParams(allele=alleles, fast=fast)
    genome.evaluator.set(eval_func)

    genome.mutator.set(Mutators.G1DListMutatorAllele)
    genome.initializator.set(Initializators.G1DListInitializatorAllele)

    gen_alg = GSimpleGA.GSimpleGA(genome)
    gen_alg.setMultiProcessing(not fast)
    gen_alg.selector.set(Selectors.GRouletteWheel)
    gen_alg.setGenerations(20)

    gen_alg.evolve(freq_stats=0)
    return gen_alg.bestIndividual()
Ejemplo n.º 4
0
 def test_AlleleRange_slicing(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     _allelerange.add(30, 40)
     self.assertEqual(_allelerange[0], (10, 20))
     _allelerange[1] = (50, 60)
     self.assertEqual(_allelerange[1], (50, 60))
     with self.assertRaises(ValueError):
         _allelerange[1] = (60, 50)
Ejemplo n.º 5
0
 def test_AlleleRange_add(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     _allelerange.add(30, 40)
     self.assertEqual(_allelerange.beginEnd, [(10, 20), (30, 40)])
     self.assertEqual(_allelerange.minimum, 10)
     self.assertEqual(_allelerange.maximum, 40)
     with self.assertRaises(ValueError):
         _allelerange.add(40, 30)
Ejemplo n.º 6
0
def run_simulation(pset, max_generations, initial_list=None):
    # Genome instance
    setOfAlleles = GAllele.GAlleles()
    setOfAlleles.add(GAllele.GAlleleRange(0, 51))
    setOfAlleles.add(GAllele.GAlleleRange(0, 6))
    setOfAlleles.add(GAllele.GAlleleRange(0, 51))

    # Genome instance, 1D List of 50 elements
    genome = G1DList.G1DList(3)
    genome.setParams(allele=setOfAlleles)

    #Fitness function

    fe = FitnessEvaluator(pset.fitness_fnc, pset.fitness_temp)
    Consts.CDefScaleLinearMultiplier = pset.fitness_temp

    application = "OS" if "oxide" in pset.fitness_fnc.__name__ else "LS"

    st = StatTrack(fe, pset.mutation_rate, pset.tournament_rate, include_ridiculous=pset.include_ridiculous, application=application)

    genome.crossover.set(pset.crossover_fnc)
    genome.mutator.set(pset.mutation_fnc)
    genome.evaluator.set(fe.array_to_score)
    genome.initializator.set(pset.initialization_fnc)

    ga = GSimpleGA.GSimpleGA(genome)

    ga.selector.set(pset.selection_fnc)
    ga.terminationCriteria.set(AllFoundCriteria)
    ga.stepCallback.set(st.evolve_callback)
    ga.setPopulationSize(pset.popsize)
    ga.setGenerations(max_generations)

    if pset.elitism_num > 0:
        ga.setElitism(True)
        ga.setElitismReplacement((int)(math.ceil(pset.elitism_num * pset.popsize)))
    else:
        ga.setElitism(False)

    ga.setMutationRate(pset.mutation_rate)
    # TODO: figure out niching
    stats_freq = 0
    ga.evolve(freq_stats=stats_freq)

    return st
Ejemplo n.º 7
0
 def test_AlleleRange_getRandomAllele(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     random_allele = _allelerange.getRandomAllele()
     self.assertTrue(
         random_allele,
         any([x[0] <= random_allele <= x[1]
              for x in _allelerange.beginEnd]))
     _allelerange.add(30, 40)
     random_allele = _allelerange.getRandomAllele()
     self.assertTrue(
         random_allele,
         any([x[0] <= random_allele <= x[1]
              for x in _allelerange.beginEnd]))
     _allelerange = GAllele.GAlleleRange(1.0, 2.0, real=True)
     random_allele = _allelerange.getRandomAllele()
     self.assertTrue(
         random_allele,
         any([x[0] <= random_allele <= x[1]
              for x in _allelerange.beginEnd]))
Ejemplo n.º 8
0
def run_main():
    # Genome instance
    setOfAlleles = GAllele.GAlleles()

    # From 0 to 10 we can have only some
    # defined ranges of integers
    for i in xrange(11):
        a = GAllele.GAlleleRange(0, i)
        setOfAlleles.add(a)

    # From 11 to 19 we can have a set
    # of elements
    for i in xrange(11, 20):
        # You can even add objects instead of strings or
        # primitive values
        a = GAllele.GAlleleList(['a', 'b', 'xxx', 666, 0])
        setOfAlleles.add(a)

    print setOfAlleles
    genome = G1DList.G1DList(20)
    genome.setParams(allele=setOfAlleles)

    # The evaluator function (objective function)
    genome.evaluator.set(eval_func)

    # This mutator and initializator will take care of
    # initializing valid individuals based on the allele set
    # that we have defined before
    genome.mutator.set(Mutators.G1DListMutatorAllele)
    genome.initializator.set(Initializators.G1DListInitializatorAllele)

    # Genetic Algorithm Instance
    ga = GSimpleGA.GSimpleGA(genome)
    ga.setGenerations(40)

    # Do the evolution, with stats dump
    # frequency of 10 generations
    ga.evolve(freq_stats=5)

    # Best individual
    print ga.bestIndividual()
Ejemplo n.º 9
0
    def run(self):
        # Allele define valid chromosome value
        alleles = GAllele.GAlleles()

        # Define gene with 2 chromosomes
        # MA type
        alleles.add(GAllele.GAlleleList([0, 1, 2, 3, 4]))
        # MA range
        alleles.add(GAllele.GAlleleRange(1, 99))

        # Genome instance, 1D List
        genome = G1DList.G1DList(len(alleles))
        # Sets the range max and min of the 1D List
        genome.setParams(allele=alleles)
        # The evaluator function (evaluation function)
        genome.evaluator.set(self.fitness)
        # This mutator and initializator will take care of
        # initializing valid individuals based on the allele set
        # that we have defined before
        genome.mutator.set(Mutators.G1DListMutatorAllele)
        genome.initializator.set(Initializators.G1DListInitializatorAllele)

        # Genetic Algorithm Instance
        ga = GSimpleGA.GSimpleGA(genome)
        # Set the Roulette Wheel selector method, the number of generations and
        # the termination criteria
        ga.selector.set(Selectors.GRouletteWheel)
        ga.setGenerations(self.gen)
        ga.setPopulationSize(self.pop)
        ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria)

        pop = ga.getPopulation()
        pop.scaleMethod.set(Scaling.SigmaTruncScaling)

        ga.evolve(freq_stats=10)
        # Best individual
        self.best = ga.bestIndividual()
Ejemplo n.º 10
0
    eta = chromo[3]
    rho = chromo[4]
    diffs = np.zeros(len(strikes) * len(terms))
    n = 0
    for i, k in enumerate(strikes):
        for j, t in enumerate(terms):
            diffs[n] = vanilla[i, j] - _heston.ucall(futs[j], k, t, v, vbar,
                                                     lambd, eta, rho)
            n += 1
    score = norm(diffs)
    return score


# Genome instance
setOfAlleles = GAllele.GAlleles()
setOfAlleles.add(GAllele.GAlleleRange(0.0, 5.0, True))
setOfAlleles.add(GAllele.GAlleleRange(0.0, 5.0, True))
setOfAlleles.add(GAllele.GAlleleRange(5.0, 15.0, True))
setOfAlleles.add(GAllele.GAlleleRange(0.0, 5.0, True))
setOfAlleles.add(GAllele.GAlleleRange(-1, 1, True))

genome = G1DList.G1DList(5)
genome.setParams(allele=setOfAlleles)
genome.evaluator.set(heston_evaluate)
genome.mutator.set(Mutators.G1DListMutatorAllele)
genome.initializator.set(Initializators.G1DListInitializatorAllele)

# Genetic Algorithm Instance
ga = GSimpleGA.GSimpleGA(genome)
# ga.setGenerations(100)
# ga.setPopulationSize(100)
Ejemplo n.º 11
0
def Grid_Constructor(numline, numParm, data):
    alleles = GAllele.GAlleles()
    for i in range(0, numline * numParm):
        alleles.add(GAllele.GAlleleRange(data[i][0], data[i][1]))
    return alleles
Ejemplo n.º 12
0
 def test_AlleleRange_repr(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     self.assertIsInstance(repr(_allelerange), str)
Ejemplo n.º 13
0
def run_ga():

    global ga

    #___________________Genome instance
    #

    setOfAlleles = GAllele.GAlleleList()

    pars_min = velocity_min + depth_min + vpvs_min
    pars_max = velocity_max + depth_max + vpvs_max
    num_pars = len(pars_min)

    for (vmin, vmax) in zip(pars_min, pars_max):

        tmp = GAllele.GAlleleRange(vmin, vmax, real=True)
        setOfAlleles.add(tmp)

    genome = G1DList.G1DList(num_pars)
    genome.setParams(allele=setOfAlleles)

    genome.initializator.set(Initializators.G1DListInitializatorAllele)
    genome.mutator.set(Mutators.G1DListMutatorAllele)
    genome.crossover.set(Crossovers.G1DListCrossoverUniform)

    #___________________The evaluator function (objective function)
    #

    genome.evaluator.set(eval_func)

    #___________________Genetic Algorithm Instance
    #

    ga = GSimpleGA.GSimpleGA(genome, seed=int(seed))

    if num_cpu: ga.setMultiProcessing(True, True, int(num_cpu))

    if ga_selector == 'T': ga.selector.set(Selectors.GTournamentSelector)
    if ga_selector == 'R': ga.selector.set(Selectors.GRouletteWheel)
    if ga_selector == 'N': ga.selector.set(Selectors.GRankSelector)

    if ga_selector == 'M':

        ga.selector.setRandomApply(True)
        ga.selector.set(Selectors.GTournamentSelector, 0.75)
        ga.selector.add(Selectors.GRouletteWheel, 0.20)
        ga.selector.add(Selectors.GRankSelector)

    ga.setMinimax(Consts.minimaxType["minimize"])
    ga.setGenerations(int(generationSize))
    ga.setPopulationSize(int(populationSize))
    ga.setCrossoverRate(pCrossover)
    ga.setMutationRate(pMutation)
    ga.setElitism(True)
    ga.setElitismReplacement(int(num_etlsm))

    #___________________Sets the DB Adapter
    #

    sqlite_adapter = DBAdapters.DBSQLite(identify=dbase_name,
                                         resetDB=eval(resetDB))
    ga.setDBAdapter(sqlite_adapter)

    #___________________Do the evolution
    #

    ga.evolve(freq_stats=5)

    #___________________Print Best individual
    #

    best = ga.bestIndividual()
    best_rs = best.getRawScore()
    best_v = best.genomeList[:len(velocity_min)]
    best_d = best.genomeList[len(velocity_min):2 * len(velocity_min)]
    best_r = best.genomeList[2 * len(velocity_min):]

    print ''
    print '+++ Best Raw Score =', best_rs
    print '+++ FinalModel :'
    print '   +++ Velocity :', rnd(best_v, 2)
    print '   +++ Depth    :', rnd(best_d, 2)
    print '   +++ VpVs     :', rnd(best_r, 2)

    return best, best_rs, best_v, best_d, best_r
Ejemplo n.º 14
0
 def test_AlleleRange_clear(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     _allelerange.clear()
     self.assertEqual(_allelerange.beginEnd, [])
Ejemplo n.º 15
0
 def test_AlleleRange_getMinimum(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     self.assertEqual(_allelerange.getMaximum(), 20)
Ejemplo n.º 16
0
 def test_AlleleRange_iter(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     self.assertIsInstance(iter(_allelerange), Iterable)
Ejemplo n.º 17
0
 def test_AlleleRange_real(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     self.assertEqual(_allelerange.getReal(), False)
     _allelerange.setReal(flag=True)
     self.assertEqual(_allelerange.getReal(), True)
Ejemplo n.º 18
0
 def test_AlleleRange_len(self):
     _allelerange = GAllele.GAlleleRange(10, 20)
     _allelerange.add(30, 40)
     self.assertEqual(len(_allelerange), 2)
Ejemplo n.º 19
0
    keys = init_cutpoints.keys()
    i = 0
    for key in keys:
        dict_[key] = chromosome[i:i+3]
        i += 3
    return dict_


chromosome_ = convert_to_list(init_cutpoints)

setOfAlleles = GAllele.GAlleles()
keys = init_cutpoints.keys()
for key in keys:
    for _ in range(0, 3):
        if key != 'cip':
            a = GAllele.GAlleleRange(int(df[key].min()), int(df[key].max()))
            setOfAlleles.add(a)
        else:
            a = GAllele.GAlleleRange(0, 10)
            setOfAlleles.add(a)

df_actual = pd.read_csv("data/Cust_Actual.csv", index_col=['index'])

genome = G1DList.G1DList(len(chromosome_))
genome.setParams(allele=setOfAlleles)

def check_sorted(chromosome):
    i = 0
    for _ in range(5):
        original = chromosome[i:i+3]
        sorted_ = sorted(original)
Ejemplo n.º 20
0
def run_main():
    # Global runner instance that will also be used by eval_func
    global runner
    global log

    # "Settings"
    working_dir = '../work'
    log_dir = '../log'
    compare_values = '../ext/Detalierte Mechanismus.csv'
    log = Logger()
    log.setLogLevel('debug')

    # load parameter format defines from parameters.py
    import parameters
    pformat = parameters.parameter_format

    # load KivaRunner
    l = Logger()
    l.setLogLevel('info')
    runner = KivaRunner(working_dir, log_dir, compare_values, pformat, l)
    if runner.error:
        return

    # Genome instance
    setOfAlleles = GAllele.GAlleles()

    # loop trough parameter format to create correct alleles
    for p in pformat:
        minimum = p[2]
        maximum = p[3]
        # log.debug("maximum: %s, minimum: %s" % (maximum, minimum))
        a = GAllele.GAlleleRange(minimum, maximum,
                                 not isinstance(minimum, int))
        setOfAlleles.add(a)

    genome = G1DList.G1DList(len(pformat))
    genome.setParams(allele=setOfAlleles)

    # The evaluator function (objective function)
    genome.evaluator.set(eval_func)

    # This mutator and initializator will take care of
    # initializing valid individuals based on the allele set
    # that we have defined before
    genome.mutator.set(Mutators.G1DListMutatorAllele)
    # genome.initializator.set(G1DListInitializatorAlleleKiva)
    genome.initializator.set(Initializators.G1DListInitializatorAllele)

    # Genetic Algorithm Instance
    ga = GSimpleGA.GSimpleGA(genome)
    ga.setGenerations(10)
    ga.setPopulationSize(20)
    ga.setMinimax(Consts.minimaxType["minimize"])
    # ga.setCrossoverRate(1.0)
    ga.setMutationRate(0.1)
    ga.selector.set(Selectors.GRouletteWheel)

    sqlite_adapter = DBAdapters.DBSQLite(identify="ex1", resetDB=True)
    ga.setDBAdapter(sqlite_adapter)

    # Do the evolution, with stats dump
    # frequency of 10 generations
    ga.evolve(freq_stats=1)

    # Best individual
    best = ga.bestIndividual()
    print "\nBest individual score: %.2f" % (best.getRawScore(), )
    print best