Python Random.seed方法代码示例

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
 def _graph_example(n=4):
     from string import ascii_uppercase as labels
     from random import Random
     n = min(n, 26)
     
     class Node(object):
         def __init__(self, letter):
             self.letter = str(letter)
             self.neigh = list()
         def __str__(self):
             return self.letter
         __repr__ = __str__
     
     # create a reproductible random graph
     nodes = [Node(x) for x in labels[:n]]
     ran = Random()
     ran.seed(6164554331563)
     neighmax = 3
     for n in nodes:
         n.neigh[:] = sorted((x for x in ran.sample(nodes, neighmax)
                                 if x is not n), key=lambda n: n.letter)
     #for n in nodes:
     #    print(n, ":", list(n.neigh))
     for path in walk(nodes[0], (lambda n: n.neigh), event(~0), tree=False):
         print(list(path), "{0:<7}".format(event_repr(path.event)))

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(prng=None, display=False):    
    if prng is None:
        prng = Random()
        prng.seed(time()) 
        
    import logging
    logger = logging.getLogger('inspyred.ec')
    logger.setLevel(logging.DEBUG)
    file_handler = logging.FileHandler('inspyred.log', mode='w')
    file_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
    
    ea = inspyred.ec.DEA(prng)
    if display:
        ea.observer = inspyred.ec.observers.stats_observer 
    ea.terminator = inspyred.ec.terminators.evaluation_termination
    final_pop = ea.evolve(generator=generate_rastrigin, 
                          evaluator=inspyred.ec.evaluators.parallel_evaluation_pp,
                          pp_evaluator=evaluate_rastrigin, 
                          pp_dependencies=(my_squaring_function,),
                          pp_modules=("math",),
                          pop_size=8, 
                          bounder=inspyred.ec.Bounder(-5.12, 5.12),
                          maximize=False,
                          max_evaluations=256,
                          num_inputs=3)
    
    if display:
        best = max(final_pop) 
        print('Best Solution: \n{0}'.format(str(best)))
    return ea

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(prng=None, display=False):
    if prng is None:
        prng = Random()
        prng.seed(time())

    items = [(80, 1),
             (0, 0),
             (80, 10)]

    problem = inspyred.benchmarks.Knapsack(100, items, duplicates=False)
    ea = inspyred.ec.EvolutionaryComputation(prng)
    ea.selector = inspyred.ec.selectors.tournament_selection
    ea.variator = [inspyred.ec.variators.uniform_crossover,
                   inspyred.ec.variators.gaussian_mutation]
    ea.replacer = inspyred.ec.replacers.steady_state_replacement
    ea.terminator = inspyred.ec.terminators.evaluation_termination

    final_pop = ea.evolve(generator=problem.generator,
                          evaluator=problem.evaluator,
                          bounder=problem.bounder,
                          maximize=problem.maximize,
                          pop_size=100,
                          max_evaluations=2500,
                          tournament_size=5,
                          num_selected=2)

    if display:
        best = max(ea.population)
        print('Best Solution: {0}: {1}'.format(str(best.candidate),
                                               best.fitness))
    return ea

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def brachistochrone():
    initial = [(float(i) / num_intervals) for i in range(num_intervals)]
    initial.append(1.0)
    initial.reverse()
    rand = Random()
    rand.seed(int(time()))
    real = initial[:]
    
    k = find_optimal(initial[:], 1000, rand)
    print duration(k)
    tenk = find_optimal(k[:], 10000, rand)
    print duration(tenk)
    #hundk = find_optimal(tenk[:], 100000, rand)
    #print duration(hundk)

    initial.reverse()
    plt.plot(initial, k, '-', lw=2)
    plt.plot(initial, tenk, '-', lw=2)
    #plt.plot(initial, hundk, '-', lw=2)


    plt.plot(initial, initial, '-', lw=2)
    real = actual(2.0)
    initial.reverse()

    plt.plot(initial, real[1], '-', lw=2)
    print duration(real[1])
    print duration(initial)

    plt.title('Brachistochrone')
    plt.grid(True)
    plt.show()

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(prng=None, display=False):
    if prng is None:
        prng = Random()
        prng.seed(time()) 

    problem = inspyred.benchmarks.Kursawe(3)
    ea = inspyred.ec.emo.NSGA2(prng)
    ea.variator = [inspyred.ec.variators.blend_crossover, 
                   inspyred.ec.variators.gaussian_mutation]
    ea.terminator = inspyred.ec.terminators.generation_termination
    final_pop = ea.evolve(generator=problem.generator, 
                          evaluator=problem.evaluator, 
                          pop_size=100,
                          maximize=problem.maximize,
                          bounder=problem.bounder,
                          max_generations=80)
    
    if display:
        final_arc = ea.archive
        print('Best Solutions: \n')
        for f in final_arc:
            print(f)
        import pylab
        x = []
        y = []
        for f in final_arc:
            x.append(f.fitness[0])
            y.append(f.fitness[1])
        pylab.scatter(x, y, color='b')
        pylab.savefig('{0} Example ({1}).pdf'.format(ea.__class__.__name__, 
                                                     problem.__class__.__name__), 
                      format='pdf')
        pylab.show()
    return ea

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
    def optimize(self,do_plot=True,seed=int(time()), summary_dir=None):

        rand = Random()
        rand.seed(seed)

        if summary_dir is None:
            cwd=os.getcwd()
            summary_dir=os.path.dirname(cwd)+'/data/'
        
        if not os.path.exists(summary_dir):
            os.mkdir(summary_dir)

        stat_file_name=summary_dir+'/ga_statistics.csv'
        ind_file_name=summary_dir+'/ga_individuals.csv'
        
        stat_file = open(stat_file_name, 'w')
        ind_file = open(ind_file_name, 'w')
        print("Created files: %s and %s"%(stat_file_name, ind_file_name))
        
        if self.verbose:
            logger = logging.getLogger('inspyred.ec')
            logger.setLevel(logging.DEBUG)

            ch = logging.StreamHandler()
            # ch.setLevel(logging.DEBUG)
            formatter = logging.Formatter('>>> EC: - %(levelname)s - %(message)s')
            ch.setFormatter(formatter)
            logger.addHandler(ch)

        algorithm = ec.EvolutionaryComputation(rand)
        algorithm.observer = observers.file_observer
        algorithm.terminator = terminators.evaluation_termination
        algorithm.selector = selectors.tournament_selection
        algorithm.replacer = replacers.steady_state_replacement
        algorithm.variator = [variators.blend_crossover, variators.gaussian_mutation]

        final_pop = algorithm.evolve(generator=self.uniform_random_chromosome,
                                     evaluator=self.evaluator.evaluate,
                                     pop_size=self.population_size,
                                     maximize=self.maximize,
                                     bounder=ec.Bounder(lower_bound=self.min_constraints,
                                                        upper_bound=self.max_constraints),
                                     num_selected=self.num_selected,
                                     tourn_size=self.tourn_size,
                                     num_elites=self.num_elites,
                                     num_offspring=self.num_offspring,
                                     max_evaluations=self.max_evaluations,
                                     mutation_rate=self.mutation_rate,
                                     statistics_file=stat_file,
                                     seeds=self.seeds,
                                     individuals_file=ind_file)

        stat_file.close()
        ind_file.close()

        self.print_report(final_pop,do_plot,stat_file_name)

        #return the parameter set for the best individual

        return final_pop[0].candidate, final_pop[0].fitness

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(): 


    g = trees.Graph("benchmark/n010d100C100c001Q100q001s-3i1.txt")

    rand = Random()
    rand.seed(int(time()))
    my_ec = inspyred.ec.EvolutionaryComputation(rand)
    my_ec.selector = inspyred.ec.selectors.tournament_selection
    my_ec.variator = [inspyred.ec.variators.crossover(crossover_tree), mutate_tree]
    my_ec.replacer = inspyred.ec.replacers.steady_state_replacement
    my_ec.terminator = [inspyred.ec.terminators.evaluation_termination, inspyred.ec.terminators.average_fitness_termination]
    my_ec.observer = observer_tree


    final_pop = my_ec.evolve(
        generator=generate_tree,
        evaluator=evaluate_tree,
        pop_size=100,
        maximize=False,
        max_evaluations=5000,
        num_selected=50,
        mutation_rate=0.25,
        c = g.c,
        q = g.q,
        v2e = g.v2e,
        best = 100000000000000
    )


    print final_pop

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
    def generateNetwork(self,nodes,rw_prob,seed):
        """
        A method for generating a Watts-Strogatz network model from specified
        parameters.

        Although a variation of this method is given in igraph,
        it does not use parameters, rather a list of dimensions, which is not
        desirable for this application.
        """
        rand = Random()
        rand.seed(seed)

        #generate a 4-regular network first
        graph = FourRegularGenerator().generateNetwork(nodes,seed)

        # iterate over all edges in the graph and select those to
        # be removed

        # a list for storing edges to be removed
        remove = []
        for i in range(0,nodes):
            rfloat = rand.random()
            if rfloat < rw_prob:
                remove.append(graph.es[i])

        # after specifying nodes to be removed, add more edges, and remove the
        # previous edges
        for i in range(0,len(remove)):
            graph.add_edges((remove[i].source,rand.randint(0,nodes-1)))
            graph.delete_edges(remove[i])

        return graph    

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main():
    global rand
    logger = logging.getLogger('inspyred.ec')
    logger.setLevel(logging.DEBUG)
    file_handler = logging.FileHandler('inspyred.log', mode='w')
    file_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
    rand = Random()
    rand.seed(int(time()))
    
    params=dict()
    params['name']='simple'
    params['debug']=True
    subsequent_runs(params)
    params=dict()
    params['name']='mutation_cooling'
    params['mutation_cooling']=0.99
    params['mutation_rate']=1.0
    params['debug']=True
    subsequent_runs(params)
    params=dict()
    params['name']='tournament_cooling'
    params['tournament_cooling']=0.99
    params['tournament_percentage']=1.0
    params['debug']=True
    subsequent_runs(params)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def CreateTable():
    try:
        global generator
        conn = MySQLdb.connect(host='localhost',user='root',passwd='asher',port=3306)

        cur = conn.cursor()
        #cmd_dropdb = 'drop database if exists bank2'
        #cur.execute(cmd_dropdb)
        cmd_createdb = 'create database if not exists bank2'
        cmd_createtable = 'create table account(id int  not null auto_increment PRIMARY KEY, kahao varchar(20), name varchar(20), sfid varchar(40),tel varchar(20), passwd varchar(40),quota varchar(20))'
        cur.execute(cmd_createdb)
        conn.select_db('bank2')
        cur.execute('%s' % cmd_createtable)
        cur.execute('alter table account AUTO_INCREMENT=1000;')
        values = []
        for i in range(len(NameList)):
            generator = Random()
            generator.seed()    # Seed from current time
#            print("darkcoding credit card generator\n")
            #kahao = credit_card_number(generator, mastercardPrefixList, 16, 1)
            kahao = credit_card_number(generator, ccbPrefixList, 16, 1)
#            print kahao
            sfid = makeNew()
            tel = TelNumber()
            password_md5 = hashlib.md5(sfid).hexdigest()
            values.append((kahao[0],NameList[i],sfid,tel,password_md5,50000))
        cur.executemany('insert into account (kahao,name,sfid,tel,passwd,quota) values(%s,%s,%s,%s,%s,%s)',values)
#        cur.execute('update account set tel="13611095014" where id=3')

        conn.commit()
        cur.close()
        conn.close()
    except MySQLdb.Error,e:
        print "Mysql Error %d: %s" % (e.args[0], e.args[1])

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
    def setUp(self):
        self.field = self._create_field()

        seed = "28391kaasd9129akdbb1o293"
        rnd = Random()
        rnd.seed(seed)
        self.field.content_gen = ContentGen(rnd)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def random_insert(circuit, choices, seed=None):
    """Insert a circuit into another quantum circuit.

    random_insert randomly selects a circuit from
    choices and randomly chooses a location to insert
    into circuit.

    Parameters
    ==========
    circuit : Gate tuple or Mul
        A tuple or Mul of Gates representing a quantum circuit
    choices : list
        Set of circuit choices
    seed : int
        Seed value for the random number generator
    """

    if len(choices) < 1:
        return circuit

    if isinstance(circuit, Mul):
        circuit = circuit.args

    # Create the random integer generator with the seed
    int_gen = Random()
    int_gen.seed(seed)

    insert_loc = int_gen.randint(0, len(circuit))
    insert_circuit_loc = int_gen.randint(0, len(choices)-1)
    insert_circuit = choices[insert_circuit_loc]

    left = circuit[0:insert_loc]
    right = circuit[insert_loc:len(circuit)]

    return left + insert_circuit + right

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(numproc=20, prng=None, display=True):
    global numberofprocessors
    numberofprocessors = numproc
    if prng is None:
        prng = Random()
        prng.seed(time.time())
    
    ea = inspyred.ec.ES(prng)
    ea.terminator = [inspyred.ec.terminators.evaluation_termination,
                     inspyred.ec.terminators.diversity_termination,
                     inspyred.ec.terminators.generation_termination]
    ea.observer = [inspyred.ec.observers.stats_observer,
                   inspyred.ec.observers.best_observer,
                   inspyred.ec.observers.file_observer]
    final_pop = ea.evolve(generator = generate_randomFDA5Params, 
                          evaluator = inspyred.ec.evaluators.parallel_evaluation_mp,
                          mp_evaluator = evaluate_FDA5, 
                          mp_nprocs = numberofprocessors,
                          pop_size = 100,
                          bounder = bound_FDA,
                          maximize = True,
                          max_evaluations = 10000,
                          max_generations = 10,
                          num_inputs=5)
    
    if display:
        best = max(final_pop)
        print('Best Solution: \n{0}'.format(str(best)))
    """

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
class Dice():
    
    def __init__(self, die = 1, sides = 6, **kw):
        self.rand = Random()
        self.rand.seed(datetime.now())
        self.die = die # Standard is 1
        self.sides = sides # Standard is 6
        
        if kw.has_key('random') and kw['random']:
            self.randomDice()
            self.randomSides()

    def __repr__(self):
        return "<Dice Die: %s - Sides: %s>" % (self.die, self.sides)
    
    def randomSides(self):
        self.sides = int(self.rand.random() * 100) + 1
        print "Die now has %s sides" % self.sides
    
    def randomDice(self):
        self.die = int(self.rand.random() * 100) + 1
        if self.die != 1:
            print "There are now %s dice to be thrown" % self.die
        else:
            print "There is only %s die to be thrown" % self.die
    
    def roll(self):
        return int(self.rand.random() * self.sides) + 1

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import seed [as 别名]
def main(prng=None, display=False):    
    if prng is None:
        prng = Random()
        prng.seed(time()) 
        
    points = [(110.0, 225.0), (161.0, 280.0), (325.0, 554.0), (490.0, 285.0), 
              (157.0, 443.0), (283.0, 379.0), (397.0, 566.0), (306.0, 360.0), 
              (343.0, 110.0), (552.0, 199.0)]
    weights = [[0 for _ in range(len(points))] for _ in range(len(points))]
    for i, p in enumerate(points):
        for j, q in enumerate(points):
            weights[i][j] = math.sqrt((p[0] - q[0])**2 + (p[1] - q[1])**2)
              
    problem = inspyred.benchmarks.TSP(weights)
    ac = inspyred.swarm.ACS(prng, problem.components)
    ac.terminator = inspyred.ec.terminators.generation_termination
    final_pop = ac.evolve(generator=problem.constructor, 
                          evaluator=problem.evaluator, 
                          bounder=problem.bounder,
                          maximize=problem.maximize, 
                          pop_size=10, 
                          max_generations=50)
    
    if display:
        best = max(ac.archive)
        print('Best Solution:')
        for b in best.candidate:
            print(points[b.element[0]])
        print(points[best.candidate[-1].element[1]])
        print('Distance: {0}'.format(1/best.fitness))
    return ac